tx · B6SERzhHhrUgsXhJxMR7EAFRJVwvrLrEyC7JTY43HRqo

3N3g7W8FPoQ7g5EadbAD2GVjrZT5RWpHZZh:  -0.01000000 Waves

2022.04.11 12:25 [2003745] smart account 3N3g7W8FPoQ7g5EadbAD2GVjrZT5RWpHZZh > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "B6SERzhHhrUgsXhJxMR7EAFRJVwvrLrEyC7JTY43HRqo",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1649669132058,
    "version": 2,
    "chainId": 84,
    "sender": "3N3g7W8FPoQ7g5EadbAD2GVjrZT5RWpHZZh",
    "senderPublicKey": "Ap7CkWd6fzBU34kGo4GJJzC5q4qWXuLVunzE25PchdGS",
    "proofs": [
        "zWXvKfwq7jyrikNo9UdicAUvaiM3cKFpDeTrCptBqt2zaXWJyiF2F7hD16cdf5JtLdNVhAPLCQkjC4yM9g2P5ey"
    ],
    "script": "base64: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",
    "height": 2003745,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: 26oPx6bESHzC3t4nahpmcnDp1kZVmeCiT4geAvE8CmKU

Full: 

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