tx · FqdELQmYqA684ZJXYknvhXXAu2KpbJc4MQRuYq9hnQXp

3NChATSZDHvSH6ugd3DbNH7cimVn56dSoX4:  -0.01900000 Waves

2023.02.22 14:57 [2460824] smart account 3NChATSZDHvSH6ugd3DbNH7cimVn56dSoX4 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "FqdELQmYqA684ZJXYknvhXXAu2KpbJc4MQRuYq9hnQXp",
    "fee": 1900000,
    "feeAssetId": null,
    "timestamp": 1677067046529,
    "version": 1,
    "sender": "3NChATSZDHvSH6ugd3DbNH7cimVn56dSoX4",
    "senderPublicKey": "J74R1yX7kVbJfJ6P4mHDtKDWPfbN6txdGAMUD3K3WVpY",
    "proofs": [
        "24USLeqo8XgiRsxU7K2bL3aHvaQx6m1kFaJusL65Hab7jCwGhKznsfc53ztfqEDK3QAjUnSj5iHZjPYRNkSvpm2P"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2460824,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: ExaaaMUokbGSpEwkBbXzTPhAeUsVfcozMcVv1KNgwRJN

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 5 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let SEP = "__"
5+
6+let wavesAssetId = "WAVES"
7+
8+let invalidPriceAsset = "Invalid price asset"
9+
10+func throwErr (msg) = throw(makeString(["user_pools.ride:", msg], " "))
11+
12+
13+func throwPD () = throwErr("Permission denied")
14+
15+
16+func throwCreateNotCalled () = throwErr("Create is not called for assets pair")
17+
18+
19+func throwYouNotIssuer () = throwErr("You are not amountAsset issuer")
20+
21+
22+func throwPoolExists () = throwErr("Pool with such assets already exists")
23+
24+
25+func throwAssetNotVerified () = throwErr("Asset is not verified")
26+
27+
28+func throwInvalidPriceAsset () = throwErr(invalidPriceAsset)
29+
30+
31+func throwInvalidFeeAsset () = throwErr("Invalid fee asset")
32+
33+
34+func throwInvalidAmountAsset () = throwErr("Invalid amount asset attached")
35+
36+
37+func throwInvalidStatus () = throwErr("Invalid status")
38+
39+
40+func throwCanActivateOnlyPendingPool () = throwErr("Can activate pool only in 'pending' status")
41+
42+
43+func throwFactoryReturnedNotString () = throwErr("FactoryV2 returned not string")
44+
45+
46+func throwInvalidPriceAssetAmount () = throwErr("invalid price asset amount")
47+
48+
49+func throwInvalidFee () = throwErr("invalid fee")
50+
51+
52+func keyManagerPublicKey () = makeString(["%s", "managerPublicKey"], SEP)
53+
54+
55+func keyPendingManagerPublicKey () = makeString(["%s", "pendingManagerPublicKey"], SEP)
56+
57+
58+func keyAdminPubKeys () = makeString(["%s", "adminPubKeys"], SEP)
59+
60+
61+func keyStatus (amountAssetId,priceAssetId) = makeString(["%s%s%s", "status", amountAssetId, priceAssetId], SEP)
62+
63+
64+func keyFactoryContract () = makeString(["%s", "factoryContract"], SEP)
65+
66+
67+func keyAssetsStoreContract () = makeString(["%s", "assetsStoreContract"], SEP)
68+
69+
70+func keyEmissionContract () = makeString(["%s", "emissionContract"], SEP)
71+
72+
73+func keySuffix (amountAssetId,priceAssetId) = makeString(["%s%s%s", "suffix", amountAssetId, priceAssetId], SEP)
74+
75+
76+func keyLastIndex () = makeString(["%s", "lastIndex"], SEP)
77+
78+
79+let indexSuffix = "u"
80+
81+let statusPending = "pending"
82+
83+let statusDeclined = "declined"
84+
85+let statusActive = "active"
86+
87+let statuses = [statusPending, statusDeclined, statusActive]
88+
89+func keyCreateCalled (amountAssetId,priceAssetId) = makeString(["%s%s%s", "createCalled", amountAssetId, priceAssetId], SEP)
90+
91+
92+func keyCreateCaller (amountAssetId,priceAssetId) = makeString(["%s%s%s", "createCaller", amountAssetId, priceAssetId], SEP)
93+
94+
95+func keyAmountAssetAmount (amountAssetId,priceAssetId) = makeString(["%s%s%s", "amountAssetAmount", amountAssetId, priceAssetId], SEP)
96+
97+
98+func keyPriceAssetAmount (amountAssetId,priceAssetId) = makeString(["%s%s%s", "priceAssetAmount", amountAssetId, priceAssetId], SEP)
99+
100+
101+func keyHeight (amountAssetId,priceAssetId) = makeString(["%s%s%s", "height", amountAssetId, priceAssetId], SEP)
102+
103+
104+func keyFeeAssetId () = makeString(["%s", "feeAssetId"], SEP)
105+
106+
107+func keyFeeAmount () = makeString(["%s", "feeAmount"], SEP)
108+
109+
110+func keyAmountAssetMinAmount () = makeString(["%s", "amountAssetMinAmount"], SEP)
111+
112+
113+func keyPriceAssetsMinAmount () = makeString(["%s", "priceAssetsMinAmount"], SEP)
114+
115+
116+func keyPriceAssets () = makeString(["%s", "priceAssets"], SEP)
117+
118+
119+func getStringOrFail (key) = valueOrErrorMessage(getString(this, key), (key + " is not defined"))
120+
121+
122+func stringOptionToList (stringOrUnit) = match stringOrUnit {
123+    case s: String => 
124+        if ((size(s) == 0))
125+            then nil
126+            else split(s, SEP)
127+    case _: Unit => 
128+        nil
129+    case _ => 
130+        throw("Match error")
131+}
132+
133+
134+let factoryContract = addressFromStringValue(getStringOrFail(keyFactoryContract()))
135+
136+func isCreateCalled (amountAssetId,priceAssetId) = valueOrElse(getBoolean(keyCreateCalled(amountAssetId, priceAssetId)), false)
137+
138+
139+func mustCreateCalled (amountAssetId,priceAssetId) = if (isCreateCalled(amountAssetId, priceAssetId))
140+    then true
141+    else throwCreateNotCalled()
142+
143+
144+func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
145+    case s: String => 
146+        fromBase58String(s)
147+    case _: Unit => 
148+        unit
149+    case _ => 
150+        throw("Match error")
151+}
152+
153+
154+func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
155+    case s: String => 
156+        fromBase58String(s)
157+    case _: Unit => 
158+        unit
159+    case _ => 
160+        throw("Match error")
161+}
162+
163+
164+func isManager (i) = match managerPublicKeyOrUnit() {
165+    case pk: ByteVector => 
166+        (i.callerPublicKey == pk)
167+    case _: Unit => 
168+        (i.caller == this)
169+    case _ => 
170+        throw("Match error")
171+}
172+
173+
174+func mustManager (i) = if (isManager(i))
175+    then true
176+    else throwPD()
177+
178+
179+func mustAdmin (i) = {
180+    let adminPKs = stringOptionToList(getString(keyAdminPubKeys()))
181+    if (containsElement(adminPKs, toBase58String(i.callerPublicKey)))
182+        then true
183+        else mustManager(i)
184+    }
185+
186+
187+func isVerified (assetId) = (valueOrElse(getInteger(addressFromStringValue(getStringOrFail(keyAssetsStoreContract())), (("status_<" + assetId) + ">")), 0) == 2)
188+
189+
190+func getIdAndInfo (payment) = match payment.assetId {
191+    case id: ByteVector => 
192+        let info = value(assetInfo(id))
193+        $Tuple2(toBase58String(id), info)
194+    case _: Unit => 
195+        $Tuple2(wavesAssetId, unit)
196+    case _ => 
197+        throw("Match error")
198+}
199+
200+
201+func validStatus (status) = containsElement(statuses, status)
202+
203+
204+@Callable(i)
205+func constructor (factoryV2Address,assetsStoreAddress,emissionAddress,priceAssetsMinAmount,amountAssetMinAmount,feeAssetId,feeAmount) = {
206+    let checkCaller = mustManager(i)
207+    if ((checkCaller == checkCaller))
208+        then [StringEntry(keyFactoryContract(), factoryV2Address), StringEntry(keyAssetsStoreContract(), assetsStoreAddress), StringEntry(keyEmissionContract(), emissionAddress), StringEntry(keyPriceAssetsMinAmount(), makeString(priceAssetsMinAmount, SEP)), IntegerEntry(keyAmountAssetMinAmount(), amountAssetMinAmount), StringEntry(keyFeeAssetId(), feeAssetId), IntegerEntry(keyFeeAmount(), feeAmount)]
209+        else throw("Strict value is not equal to itself.")
210+    }
211+
212+
213+
214+@Callable(i)
215+func create () = {
216+    let amountAssetPayment = value(i.payments[0])
217+    let priceAssetPayment = value(i.payments[1])
218+    let feeAssetPayment = value(i.payments[2])
219+    let $t067946866 = getIdAndInfo(amountAssetPayment)
220+    let amountAssetId = $t067946866._1
221+    let amountAssetInfo = $t067946866._2
222+    let $t068706939 = getIdAndInfo(priceAssetPayment)
223+    let priceAssetId = $t068706939._1
224+    let priceAssetInfo = $t068706939._2
225+    let $t069437006 = getIdAndInfo(feeAssetPayment)
226+    let feeAssetId = $t069437006._1
227+    let feeAssetInfo = $t069437006._2
228+    let priceAssetsList = stringOptionToList(getString(factoryContract, keyPriceAssets()))
229+    let managerPriceAssetMinAmount = 1
230+    let priceAssetMinAmount = if (isManager(i))
231+        then managerPriceAssetMinAmount
232+        else {
233+            let priceAssetsIndex = valueOrErrorMessage(indexOf(priceAssetsList, priceAssetId), invalidPriceAsset)
234+            value(parseInt(stringOptionToList(getString(keyPriceAssetsMinAmount()))[priceAssetsIndex]))
235+            }
236+    let lastIndex = valueOrElse(getInteger(keyLastIndex()), 0)
237+    let curIndex = (lastIndex + 1)
238+    let emissionContract = addressFromStringValue(getStringOrFail(keyEmissionContract()))
239+    let checks = [if (!(isCreateCalled(amountAssetId, priceAssetId)))
240+        then true
241+        else throwPoolExists(), if (if (isManager(i))
242+        then true
243+        else isVerified(amountAssetId))
244+        then true
245+        else throwAssetNotVerified(), if ((getString(keyFeeAssetId()) == feeAssetId))
246+        then true
247+        else throwInvalidFeeAsset(), if (if (isManager(i))
248+        then true
249+        else (amountAssetPayment.amount >= getIntegerValue(keyAmountAssetMinAmount())))
250+        then true
251+        else throwInvalidAmountAsset(), if (if (isManager(i))
252+        then true
253+        else (priceAssetPayment.amount >= priceAssetMinAmount))
254+        then true
255+        else throwInvalidPriceAssetAmount(), if ((feeAssetPayment.amount == getInteger(keyFeeAmount())))
256+        then true
257+        else throwInvalidFee()]
258+    if ((checks == checks))
259+        then {
260+            let burnEmissionInv = invoke(emissionContract, "burn", nil, [AttachedPayment(fromBase58String(feeAssetId), feeAssetPayment.amount)])
261+            if ((burnEmissionInv == burnEmissionInv))
262+                then [BooleanEntry(keyCreateCalled(amountAssetId, priceAssetId), true), StringEntry(keyCreateCaller(amountAssetId, priceAssetId), toString(i.caller)), IntegerEntry(keyLastIndex(), curIndex), StringEntry(keySuffix(amountAssetId, priceAssetId), (toString(curIndex) + indexSuffix)), IntegerEntry(keyHeight(amountAssetId, priceAssetId), height), StringEntry(keyStatus(amountAssetId, priceAssetId), statusPending), IntegerEntry(keyAmountAssetAmount(amountAssetId, priceAssetId), amountAssetPayment.amount), IntegerEntry(keyPriceAssetAmount(amountAssetId, priceAssetId), priceAssetPayment.amount)]
263+                else throw("Strict value is not equal to itself.")
264+            }
265+        else throw("Strict value is not equal to itself.")
266+    }
267+
268+
269+
270+@Callable(i)
271+func activate (poolAddress,amountAssetId,amountAssetTicker,priceAssetId,priceAssetTicker,logo) = {
272+    let checks = [mustAdmin(i), if (isCreateCalled(amountAssetId, priceAssetId))
273+        then true
274+        else throwCreateNotCalled(), if ((value(getString(keyStatus(amountAssetId, priceAssetId))) == statusPending))
275+        then true
276+        else throwCanActivateOnlyPendingPool()]
277+    if ((checks == checks))
278+        then {
279+            let activateNewPoolInv = invoke(factoryContract, "activateNewPool", [poolAddress, amountAssetId, priceAssetId, ((amountAssetTicker + priceAssetTicker) + "LP"), (((amountAssetTicker + "/") + priceAssetTicker) + " pool liquidity provider token"), 0, "VLTPOOL", logo], nil)
280+            if ((activateNewPoolInv == activateNewPoolInv))
281+                then {
282+                    let lpAssetId =                     match activateNewPoolInv {
283+                        case id: String => 
284+                            id
285+                        case _ => 
286+                            throwFactoryReturnedNotString()
287+                    }
288+                    if ((lpAssetId == lpAssetId))
289+                        then {
290+                            let beforePut = assetBalance(this, fromBase58String(lpAssetId))
291+                            if ((beforePut == beforePut))
292+                                then {
293+                                    let put = invoke(addressFromStringValue(poolAddress), "put", [0, false], [AttachedPayment(if ((amountAssetId == "WAVES"))
294+                                        then unit
295+                                        else fromBase58String(amountAssetId), value(getInteger(keyAmountAssetAmount(amountAssetId, priceAssetId)))), AttachedPayment(if ((priceAssetId == "WAVES"))
296+                                        then unit
297+                                        else fromBase58String(priceAssetId), value(getInteger(keyPriceAssetAmount(amountAssetId, priceAssetId))))])
298+                                    if ((put == put))
299+                                        then {
300+                                            let afterPut = assetBalance(this, fromBase58String(lpAssetId))
301+                                            if ((afterPut == afterPut))
302+                                                then {
303+                                                    let user = value(addressFromString(value(getString(keyCreateCaller(amountAssetId, priceAssetId)))))
304+[StringEntry(keyStatus(amountAssetId, priceAssetId), statusActive), ScriptTransfer(user, (afterPut - beforePut), fromBase58String(lpAssetId))]
305+                                                    }
306+                                                else throw("Strict value is not equal to itself.")
307+                                            }
308+                                        else throw("Strict value is not equal to itself.")
309+                                    }
310+                                else throw("Strict value is not equal to itself.")
311+                            }
312+                        else throw("Strict value is not equal to itself.")
313+                    }
314+                else throw("Strict value is not equal to itself.")
315+            }
316+        else throw("Strict value is not equal to itself.")
317+    }
318+
319+
320+
321+@Callable(i)
322+func setAdmins (adminPubKeys) = {
323+    let checkCaller = mustManager(i)
324+    if ((checkCaller == checkCaller))
325+        then [StringEntry(keyAdminPubKeys(), makeString(adminPubKeys, SEP))]
326+        else throw("Strict value is not equal to itself.")
327+    }
328+
329+
330+
331+@Callable(i)
332+func setManager (pendingManagerPublicKey) = {
333+    let checkCaller = mustManager(i)
334+    if ((checkCaller == checkCaller))
335+        then {
336+            let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
337+            if ((checkManagerPublicKey == checkManagerPublicKey))
338+                then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
339+                else throw("Strict value is not equal to itself.")
340+            }
341+        else throw("Strict value is not equal to itself.")
342+    }
343+
344+
345+
346+@Callable(i)
347+func confirmManager () = {
348+    let pm = pendingManagerPublicKeyOrUnit()
349+    let hasPM = if (isDefined(pm))
350+        then true
351+        else throw("No pending manager")
352+    if ((hasPM == hasPM))
353+        then {
354+            let checkPM = if ((i.callerPublicKey == value(pm)))
355+                then true
356+                else throw("You are not pending manager")
357+            if ((checkPM == checkPM))
358+                then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
359+                else throw("Strict value is not equal to itself.")
360+            }
361+        else throw("Strict value is not equal to itself.")
362+    }
363+
364+
365+
366+@Callable(i)
367+func priceAssetsREADONLY () = $Tuple2(nil, stringOptionToList(getString(keyPriceAssets())))
368+
369+
370+
371+@Callable(i)
372+func statusREADONLY (amountAssetId,priceAssetId) = {
373+    let status =     match getString(keyStatus(amountAssetId, priceAssetId)) {
374+        case s: String => 
375+            s
376+        case _ => 
377+            unit
378+    }
379+    $Tuple2(nil, status)
380+    }
381+
382+
383+@Verifier(tx)
384+func verify () = {
385+    let targetPublicKey =     match managerPublicKeyOrUnit() {
386+        case pk: ByteVector => 
387+            pk
388+        case _: Unit => 
389+            tx.senderPublicKey
390+        case _ => 
391+            throw("Match error")
392+    }
393+    sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
394+    }
395+
github/deemru/w8io/169f3d6 
39.15 ms ◑