tx · EDKZ9pib89tz9cdsiESQTQJs8yB5peivDT1mm5aHDk22

3Mvd8vrY4yvQHw1STnJaev4eoUfYBfoG2EZ:  -0.01000000 Waves

2022.05.09 19:27 [2044380] smart account 3Mvd8vrY4yvQHw1STnJaev4eoUfYBfoG2EZ > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "EDKZ9pib89tz9cdsiESQTQJs8yB5peivDT1mm5aHDk22",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1652113654206,
    "version": 2,
    "chainId": 84,
    "sender": "3Mvd8vrY4yvQHw1STnJaev4eoUfYBfoG2EZ",
    "senderPublicKey": "6V9fXn9SmPYSBHp8hrVEVjLi2oqqwUHwbVihxGdL6Mk3",
    "proofs": [
        "5wowyweJQW4UWrJbRPdin6iFnjzu5qAbjVNGRyrBtdrUWfetKrHHyw6jbLkqYULPZDHSGKMx1b48QR6n3fHS2AVv"
    ],
    "script": "base64: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",
    "height": 2044380,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: 8XDhjJ7hmsfxB4LCBaSgvTxBsF8Q7CQfDLPFym73e9oF

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 5 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let keyAssetAddress = "_aa"
5+
6+let keyAssetType = "_at"
7+
8+let keyAssetPrecision = "_ap"
9+
10+let keyAssetMinFee = "_amf"
11+
12+let keyAssetIsActive = "_aia"
13+
14+let ketBaseFeeRateBP = "_bfr"
15+
16+let keyValidator = "_v"
17+
18+let keyFeeCollector = "_fc"
19+
20+let keyUnlockSigner = "_us"
21+
22+let keyIsActive = "_ia"
23+
24+let keyManager = "_m"
25+
26+let BRIDGE_MANAGER = "BRIDGE_MANAGER"
27+
28+let ASSET_MANAGER = "ASSET_MANAGER"
29+
30+let STOP_MANAGER = "STOP_MANAGER"
31+
32+let baseAssetSourceAndAddress = base58'FbV8QW7Jusz'
33+
34+let baseAssetId = base58'3EMsPJ'
35+
36+let chainWaves = base58'3EMsPJ'
37+
38+let BP = 10000
39+
40+let systemPrecision = 9
41+
42+let errUnauthorized = "unauthorized"
43+
44+let errUninitialized = "uninitialized"
45+
46+let errInitialized = "initialized"
47+
48+let errAlreadyExists = "exists"
49+
50+let errNotExists = "not exists"
51+
52+let errInvalidValues = "invalid values"
53+
54+let errNotOnePayment = "not one payment"
55+
56+let errAssetNotFound = "asset not found"
57+
58+let errNotEnoughBalance = "not enough balance"
59+
60+let errBigPowValue = "pow value too big"
61+
62+let errBridgeDisabled = "birdge is disabled"
63+
64+let errAssetDisabled = "asset is disabled"
65+
66+let typeBase = 0
67+
68+let typeNative = 1
69+
70+let typeWrapped = 2
71+
72+func assertCallerIsManager (i,managerType) = match getBinary((managerType + keyManager)) {
73+    case authority: ByteVector => 
74+        if ((authority != i.caller.bytes))
75+            then throw(errUnauthorized)
76+            else unit
77+    case _ => 
78+        throw(errUninitialized)
79+}
80+
81+
82+func assertBridgeIsActive () = if (!(valueOrElse(getBoolean(keyIsActive), false)))
83+    then throw(errBridgeDisabled)
84+    else unit
85+
86+
87+func assertAssetIsActive (assetIdStr) = match getBoolean((assetIdStr + keyAssetIsActive)) {
88+    case isActive: Boolean => 
89+        if (isActive)
90+            then unit
91+            else throw(errAssetDisabled)
92+    case _ => 
93+        throw(errAssetNotFound)
94+}
95+
96+
97+func getFee (amount,assetIdStr) = {
98+    let baseFeeRateBP = valueOrErrorMessage(getInteger(ketBaseFeeRateBP), errUninitialized)
99+    let minFee = valueOrErrorMessage(getInteger((assetIdStr + keyAssetMinFee)), errAssetNotFound)
100+    let fee = ((amount * baseFeeRateBP) / BP)
101+    if ((minFee > fee))
102+        then minFee
103+        else fee
104+    }
105+
106+
107+func pow10 (value,power) = {
108+    let absPow = if ((0 > power))
109+        then -(power)
110+        else power
111+    let powerValue = if ((absPow == 0))
112+        then 1
113+        else if ((absPow == 1))
114+            then 10
115+            else if ((absPow == 2))
116+                then 100
117+                else if ((absPow == 3))
118+                    then 1000
119+                    else if ((absPow == 4))
120+                        then 10000
121+                        else if ((absPow == 5))
122+                            then 100000
123+                            else if ((absPow == 6))
124+                                then 1000000
125+                                else if ((absPow == 7))
126+                                    then 10000000
127+                                    else if ((absPow == 8))
128+                                        then 100000000
129+                                        else if ((absPow == 9))
130+                                            then 1000000000
131+                                            else throw(errBigPowValue)
132+    if ((0 > power))
133+        then (value / powerValue)
134+        else (value * powerValue)
135+    }
136+
137+
138+func toSystemPrecision (amount,precision) = pow10(amount, (systemPrecision - precision))
139+
140+
141+func fromSystemPrecision (amount,precision) = pow10(amount, (precision - systemPrecision))
142+
143+
144+@Callable(i)
145+func setConfig (admin,validatorAddress,feeCollector,unlockSigner,baseFeeRateBP) = if (isDefined(getBinary((BRIDGE_MANAGER + keyManager))))
146+    then throw(errInitialized)
147+    else [BinaryEntry((BRIDGE_MANAGER + keyManager), admin), BinaryEntry(keyValidator, validatorAddress), BinaryEntry(keyFeeCollector, feeCollector), BinaryEntry(keyUnlockSigner, unlockSigner), IntegerEntry(ketBaseFeeRateBP, baseFeeRateBP), BooleanEntry(keyIsActive, true)]
148+
149+
150+
151+@Callable(i)
152+func addAsset (assetSourceAndAddress,assetIdArg,type,name,description,precision,minFee) = {
153+    let callerCheck = assertCallerIsManager(i, ASSET_MANAGER)
154+    if ((callerCheck == callerCheck))
155+        then {
156+            let $t040994858 = if ((type == typeBase))
157+                then if (if (if ((assetSourceAndAddress != baseAssetSourceAndAddress))
158+                    then true
159+                    else (assetIdArg != baseAssetId))
160+                    then true
161+                    else (precision != 8))
162+                    then throw(errInvalidValues)
163+                    else $Tuple2(nil, assetIdArg)
164+                else if ((type == typeNative))
165+                    then $Tuple2(nil, assetIdArg)
166+                    else if ((type == typeWrapped))
167+                        then if ((size(assetIdArg) == 0))
168+                            then {
169+                                let issue = Issue(name, description, 0, precision, true)
170+                                $Tuple2([issue], calculateAssetId(issue))
171+                                }
172+                            else $Tuple2(nil, assetIdArg)
173+                        else throw(errInvalidValues)
174+            let actions = $t040994858._1
175+            let assetId = $t040994858._2
176+            let assetIdStr = toBase64String(assetId)
177+            let keySourceAddress = (toBase64String(assetSourceAndAddress) + keyAssetAddress)
178+            let keyNativeAddress = (assetIdStr + keyAssetAddress)
179+            if (if (isDefined(getBinary(keySourceAddress)))
180+                then true
181+                else isDefined(getBinary(keyNativeAddress)))
182+                then throw(errAlreadyExists)
183+                else (actions ++ [BinaryEntry(keySourceAddress, assetId), BinaryEntry(keyNativeAddress, assetSourceAndAddress), IntegerEntry((assetIdStr + keyAssetType), type), IntegerEntry((assetIdStr + keyAssetPrecision), precision), IntegerEntry((assetIdStr + keyAssetMinFee), minFee), BooleanEntry((assetIdStr + keyAssetIsActive), true)])
184+            }
185+        else throw("Strict value is not equal to itself.")
186+    }
187+
188+
189+
190+@Callable(i)
191+func removeAsset (assetSourceAndAddress,newAuthority) = {
192+    let callerCheck = assertCallerIsManager(i, ASSET_MANAGER)
193+    if ((callerCheck == callerCheck))
194+        then {
195+            let keySourceAddress = (toBase64String(assetSourceAndAddress) + keyAssetAddress)
196+            let assetId = valueOrErrorMessage(getBinary(keySourceAddress), errNotExists)
197+            let assetIdStr = toBase64String(assetId)
198+            let type = valueOrErrorMessage(getInteger((assetIdStr + keyAssetType)), errNotExists)
199+            let actions = if ((type == typeBase))
200+                then {
201+                    let balance = wavesBalance(this)
202+                    if ((balance.available > 0))
203+                        then [ScriptTransfer(Address(newAuthority), balance.available, unit)]
204+                        else nil
205+                    }
206+                else if ((type == typeNative))
207+                    then {
208+                        let balance = assetBalance(this, assetId)
209+                        if ((balance > 0))
210+                            then [ScriptTransfer(Address(newAuthority), balance, assetId)]
211+                            else nil
212+                        }
213+                    else if ((type == typeWrapped))
214+                        then nil
215+                        else throw(errInvalidValues)
216+            (actions ++ [DeleteEntry(keySourceAddress), DeleteEntry((assetIdStr + keyAssetAddress)), DeleteEntry((assetIdStr + keyAssetType)), DeleteEntry((assetIdStr + keyAssetPrecision)), DeleteEntry((assetIdStr + keyAssetMinFee)), DeleteEntry((assetIdStr + keyAssetIsActive))])
217+            }
218+        else throw("Strict value is not equal to itself.")
219+    }
220+
221+
222+
223+@Callable(i)
224+func lock (lockId,recipient,destination) = {
225+    let birdgeCheck = assertBridgeIsActive()
226+    if ((birdgeCheck == birdgeCheck))
227+        then if ((size(i.payments) != 1))
228+            then throw(errNotOnePayment)
229+            else {
230+                let assetId = valueOrElse(i.payments[0].assetId, baseAssetId)
231+                let assetIdStr = toBase64String(assetId)
232+                let assetCheck = assertAssetIsActive(assetIdStr)
233+                if ((assetCheck == assetCheck))
234+                    then {
235+                        let amount = i.payments[0].amount
236+                        let validatorAddress = valueOrErrorMessage(getBinary(keyValidator), errUninitialized)
237+                        let fee = getFee(amount, assetIdStr)
238+                        let amountWithoutFee = (amount - fee)
239+                        if ((0 >= amountWithoutFee))
240+                            then throw(errNotEnoughBalance)
241+                            else {
242+                                let assetSourceAndAddress = valueOrErrorMessage(getBinary((assetIdStr + keyAssetAddress)), errAssetNotFound)
243+                                let type = valueOrErrorMessage(getInteger((assetIdStr + keyAssetType)), errAssetNotFound)
244+                                let precision = valueOrErrorMessage(getInteger((assetIdStr + keyAssetPrecision)), errAssetNotFound)
245+                                let feeCollector = valueOrErrorMessage(getBinary(keyFeeCollector), errUninitialized)
246+                                let createLock = invoke(Address(validatorAddress), "createLock", [lockId, recipient, toSystemPrecision(amountWithoutFee, precision), destination, assetSourceAndAddress], nil)
247+                                if ((createLock == createLock))
248+                                    then if ((type == typeBase))
249+                                        then [ScriptTransfer(Address(feeCollector), fee, unit)]
250+                                        else if ((type == typeNative))
251+                                            then [ScriptTransfer(Address(feeCollector), fee, assetId)]
252+                                            else if ((type == typeWrapped))
253+                                                then [Burn(assetId, amountWithoutFee), ScriptTransfer(Address(feeCollector), fee, assetId)]
254+                                                else throw(errInvalidValues)
255+                                    else throw("Strict value is not equal to itself.")
256+                                }
257+                        }
258+                    else throw("Strict value is not equal to itself.")
259+                }
260+        else throw("Strict value is not equal to itself.")
261+    }
262+
263+
264+
265+@Callable(i)
266+func unlock (lockId,recipient,amount,lockSource,assetSourceAndAddress,signature) = {
267+    let birdgeCheck = assertBridgeIsActive()
268+    if ((birdgeCheck == birdgeCheck))
269+        then {
270+            let assetId = valueOrErrorMessage(getBinary((toBase64String(assetSourceAndAddress) + keyAssetAddress)), errAssetNotFound)
271+            let assetIdStr = toBase64String(assetId)
272+            let type = valueOrErrorMessage(getInteger((assetIdStr + keyAssetType)), errAssetNotFound)
273+            let precision = valueOrErrorMessage(getInteger((assetIdStr + keyAssetPrecision)), errAssetNotFound)
274+            let validatorAddress = valueOrErrorMessage(getBinary(keyValidator), errUninitialized)
275+            let unlockSigner = valueOrErrorMessage(getBinary(keyUnlockSigner), errUninitialized)
276+            let feeCollector = valueOrErrorMessage(getBinary(keyFeeCollector), errUninitialized)
277+            let createUnlock = invoke(Address(validatorAddress), "createUnlock", [lockId, recipient, amount, lockSource, assetSourceAndAddress, signature], nil)
278+            if ((createUnlock == createUnlock))
279+                then {
280+                    let isValid =                     match createUnlock {
281+                        case v: Boolean => 
282+                            v
283+                        case _ => 
284+                            false
285+                    }
286+                    if (!(isValid))
287+                        then throw(errInvalidValues)
288+                        else {
289+                            let fee = if ((unlockSigner == i.caller.bytes))
290+                                then valueOrErrorMessage(getInteger((assetIdStr + keyAssetMinFee)), errAssetNotFound)
291+                                else 0
292+                            let amountToSend = fromSystemPrecision(amount, precision)
293+                            let amountToSendWithoutFee = (amountToSend - fee)
294+                            if ((0 >= amountToSendWithoutFee))
295+                                then throw(errNotEnoughBalance)
296+                                else if ((type == typeBase))
297+                                    then ([ScriptTransfer(Address(recipient), amountToSendWithoutFee, unit)] ++ (if ((fee > 0))
298+                                        then [ScriptTransfer(Address(feeCollector), fee, unit)]
299+                                        else nil))
300+                                    else if ((type == typeNative))
301+                                        then ([ScriptTransfer(Address(recipient), amountToSendWithoutFee, assetId)] ++ (if ((fee > 0))
302+                                            then [ScriptTransfer(Address(feeCollector), fee, assetId)]
303+                                            else nil))
304+                                        else if ((type == typeWrapped))
305+                                            then ([Reissue(assetId, amountToSend, true), ScriptTransfer(Address(recipient), amountToSendWithoutFee, assetId)] ++ (if ((fee > 0))
306+                                                then [ScriptTransfer(Address(feeCollector), fee, assetId)]
307+                                                else nil))
308+                                            else throw(errInvalidValues)
309+                            }
310+                    }
311+                else throw("Strict value is not equal to itself.")
312+            }
313+        else throw("Strict value is not equal to itself.")
314+    }
315+
316+
317+
318+@Callable(i)
319+func setManager (managerType,manager) = {
320+    let callerCheck = assertCallerIsManager(i, BRIDGE_MANAGER)
321+    if ((callerCheck == callerCheck))
322+        then [BinaryEntry((managerType + keyManager), manager)]
323+        else throw("Strict value is not equal to itself.")
324+    }
325+
326+
327+
328+@Callable(i)
329+func setFeeCollector (feeCollector) = {
330+    let callerCheck = assertCallerIsManager(i, BRIDGE_MANAGER)
331+    if ((callerCheck == callerCheck))
332+        then [BinaryEntry(keyFeeCollector, feeCollector)]
333+        else throw("Strict value is not equal to itself.")
334+    }
335+
336+
337+
338+@Callable(i)
339+func setValidator (validator) = {
340+    let callerCheck = assertCallerIsManager(i, BRIDGE_MANAGER)
341+    if ((callerCheck == callerCheck))
342+        then [BinaryEntry(keyValidator, validator)]
343+        else throw("Strict value is not equal to itself.")
344+    }
345+
346+
347+
348+@Callable(i)
349+func startBridge () = {
350+    let callerCheck = assertCallerIsManager(i, BRIDGE_MANAGER)
351+    if ((callerCheck == callerCheck))
352+        then [BooleanEntry(keyIsActive, true)]
353+        else throw("Strict value is not equal to itself.")
354+    }
355+
356+
357+
358+@Callable(i)
359+func stopBridge () = {
360+    let callerCheck = assertCallerIsManager(i, STOP_MANAGER)
361+    if ((callerCheck == callerCheck))
362+        then [BooleanEntry(keyIsActive, false)]
363+        else throw("Strict value is not equal to itself.")
364+    }
365+
366+
367+
368+@Callable(i)
369+func setMinFee (assetId,minFee) = {
370+    let callerCheck = assertCallerIsManager(i, BRIDGE_MANAGER)
371+    if ((callerCheck == callerCheck))
372+        then {
373+            let assetIdStr = toBase64String(assetId)
374+[IntegerEntry((assetIdStr + keyAssetMinFee), minFee)]
375+            }
376+        else throw("Strict value is not equal to itself.")
377+    }
378+
379+
380+
381+@Callable(i)
382+func setBaseFeeRate (baseFeeRateBP) = {
383+    let callerCheck = assertCallerIsManager(i, BRIDGE_MANAGER)
384+    if ((callerCheck == callerCheck))
385+        then [IntegerEntry(ketBaseFeeRateBP, baseFeeRateBP)]
386+        else throw("Strict value is not equal to itself.")
387+    }
388+
389+
390+
391+@Callable(i)
392+func setAssetState (assetId,state) = {
393+    let callerCheck = assertCallerIsManager(i, BRIDGE_MANAGER)
394+    if ((callerCheck == callerCheck))
395+        then {
396+            let assetIdStr = toBase64String(assetId)
397+[BooleanEntry((assetIdStr + keyAssetIsActive), state)]
398+            }
399+        else throw("Strict value is not equal to itself.")
400+    }
401+
402+
github/deemru/w8io/3ef1775 
38.28 ms ◑