tx · ByNGaMUqkErvMddgj5c9BX2Yf5iToVH6CA8ppUs1G9WZ

3NCCbzmJYurqgXL9bh85G7gzASswGVjkfRU:  -0.01300000 Waves

2024.03.22 14:49 [3029204] smart account 3NCCbzmJYurqgXL9bh85G7gzASswGVjkfRU > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "ByNGaMUqkErvMddgj5c9BX2Yf5iToVH6CA8ppUs1G9WZ",
    "fee": 1300000,
    "feeAssetId": null,
    "timestamp": 1711108201395,
    "version": 2,
    "chainId": 84,
    "sender": "3NCCbzmJYurqgXL9bh85G7gzASswGVjkfRU",
    "senderPublicKey": "7dYS4cBUtMS3qg16og5S9C9U6ygyVxgTqhJGoYcsuYzr",
    "proofs": [
        "3LBTQBQEbPVYnx8jZvoZKc4Zov4yiEayVhWuXtEvuRi1mQrdbzCgpEjMjZAB7mU6tMca8qhvsbC6Lcn262xNnB69"
    ],
    "script": "base64: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",
    "height": 3029204,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: CLk4CVvdQTVRU3ieWRkRFxpCDa1h1QrAJPCPCMGJaSTo

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 7 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let SEPARATOR = "__"
5+
6+let KEY_MULTISIG = "MULTISIG"
7+
8+let KEY_STATUS = "STATUS"
9+
10+let KEY_INIT = "INIT"
11+
12+let KEY_PAUSED = "PAUSED"
13+
14+let KEY_PAUSER = "PAUSER"
15+
16+let KEY_EXECUTOR = "EXECUTOR"
17+
18+let KEY_CALLER_CONTRACT = "CALLER_CONTRACT"
19+
20+let KEY_WAVES_VAULT = "WAVES_VAULT"
21+
22+let KEY_ACCOUNT_STORAGE = "ACCOUNT_STORAGE"
23+
24+let KEY_CHAIN = "CHAIN"
25+
26+let KEY_ASSET_TICKER = "ASSET_TICKER"
27+
28+let KEY_ASSET_RESERVES = "ASSET_RESERVES"
29+
30+let KEY_TICKER_RESERVES = "TICKER_RESERVES"
31+
32+let FUNC_DEPOSIT = "deposit"
33+
34+let WAVES = "WAVES"
35+
36+let SPOT_WALLET = "SPOT"
37+
38+let MAX_INT = 9223372036854775807
39+
40+let ZERO_BIGINT = toBigInt(0)
41+
42+let ONE_BIGINT = toBigInt(1)
43+
44+func _validateAddress (address_,err_) = match addressFromString(address_) {
45+    case a: Address => 
46+        true
47+    case _ => 
48+        throw(err_)
49+}
50+
51+
52+func _validateInt (val_,lowerBoundary_,upperBoundary_,err_) = if (if ((lowerBoundary_ > val_))
53+    then true
54+    else (val_ > upperBoundary_))
55+    then throw(err_)
56+    else true
57+
58+
59+func _validateBigInt (val_,lowerBoundary_,err_) = if ((lowerBoundary_ > val_))
60+    then throw(err_)
61+    else true
62+
63+
64+func _validateString (val_,err_) = if (if ((0 >= size(val_)))
65+    then true
66+    else contains(val_, SEPARATOR))
67+    then throw(err_)
68+    else true
69+
70+
71+func _loadInit () = match getBoolean(KEY_INIT) {
72+    case a: Boolean => 
73+        a
74+    case _ => 
75+        false
76+}
77+
78+
79+func _saveInit (isInit_) = [BooleanEntry(KEY_INIT, isInit_)]
80+
81+
82+func _loadPause () = match getBoolean(KEY_PAUSED) {
83+    case a: Boolean => 
84+        a
85+    case _ => 
86+        false
87+}
88+
89+
90+func _savePause (isPaused_) = [BooleanEntry(KEY_PAUSED, isPaused_)]
91+
92+
93+func _loadPauser () = match getString(KEY_PAUSER) {
94+    case a: String => 
95+        addressFromStringValue(a)
96+    case _ => 
97+        Address(base58'')
98+}
99+
100+
101+func _savePauser (pauser_) = [StringEntry(KEY_PAUSER, toString(pauser_))]
102+
103+
104+func _loadMultisig () = match getString(KEY_MULTISIG) {
105+    case a: String => 
106+        addressFromStringValue(a)
107+    case _ => 
108+        Address(base58'')
109+}
110+
111+
112+func _saveMultisig (multisig_) = [StringEntry(KEY_MULTISIG, toString(multisig_))]
113+
114+
115+func _loadCallerContract (chainId_) = match getString(makeString([KEY_CALLER_CONTRACT, toString(chainId_)], SEPARATOR)) {
116+    case a: String => 
117+        a
118+    case _ => 
119+        ""
120+}
121+
122+
123+func _saveCallerContract (chainId_,callerContract_) = [StringEntry(makeString([KEY_CALLER_CONTRACT, toString(chainId_)], SEPARATOR), callerContract_)]
124+
125+
126+func _loadExecutor () = match getString(KEY_EXECUTOR) {
127+    case a: String => 
128+        addressFromStringValue(a)
129+    case _ => 
130+        Address(base58'')
131+}
132+
133+
134+func _saveExecutor (executor_) = [StringEntry(KEY_EXECUTOR, toString(executor_))]
135+
136+
137+func _loadAccountStorage () = match getString(KEY_ACCOUNT_STORAGE) {
138+    case a: String => 
139+        addressFromStringValue(a)
140+    case _ => 
141+        Address(base58'')
142+}
143+
144+
145+func _saveAccountStorage (accountStorage_) = [StringEntry(KEY_ACCOUNT_STORAGE, toString(accountStorage_))]
146+
147+
148+func _loadWavesVault () = match getString(KEY_WAVES_VAULT) {
149+    case a: String => 
150+        addressFromStringValue(a)
151+    case _ => 
152+        Address(base58'')
153+}
154+
155+
156+func _saveWavesVault (wavesVault_) = [StringEntry(KEY_WAVES_VAULT, toString(wavesVault_))]
157+
158+
159+func _loadChain (chainId_) = match getString(makeString([KEY_CHAIN, toString(chainId_)], SEPARATOR)) {
160+    case a: String => 
161+        a
162+    case _ => 
163+        ""
164+}
165+
166+
167+func _saveChain (chainId_,name_) = [StringEntry(makeString([KEY_CHAIN, toString(chainId_)], SEPARATOR), name_)]
168+
169+
170+func _loadAssetTicker (chainId_,asset_) = match getString(makeString([KEY_ASSET_TICKER, toString(chainId_), asset_], SEPARATOR)) {
171+    case a: String => 
172+        a
173+    case _ => 
174+        ""
175+}
176+
177+
178+func _saveAssetTicker (chainId_,asset_,ticker_) = [StringEntry(makeString([KEY_ASSET_TICKER, toString(chainId_), asset_], SEPARATOR), ticker_)]
179+
180+
181+func _loadAssetReserves (chainId_,asset_) = match getString(makeString([KEY_ASSET_RESERVES, toString(chainId_), asset_], SEPARATOR)) {
182+    case a: String => 
183+        parseBigIntValue(a)
184+    case _ => 
185+        ZERO_BIGINT
186+}
187+
188+
189+func _saveAssetReserves (chainId_,asset_,reserves_) = [StringEntry(makeString([KEY_ASSET_RESERVES, toString(chainId_), asset_], SEPARATOR), toString(reserves_))]
190+
191+
192+func _loadTickerReserves (ticker_) = match getString(makeString([KEY_TICKER_RESERVES, ticker_], SEPARATOR)) {
193+    case a: String => 
194+        parseBigIntValue(a)
195+    case _ => 
196+        ZERO_BIGINT
197+}
198+
199+
200+func _saveTickerReserves (ticker_,reserves_) = [StringEntry(makeString([KEY_TICKER_RESERVES, ticker_], SEPARATOR), toString(reserves_))]
201+
202+
203+func _onlyThisContract (caller_) = if ((caller_ != this))
204+    then throw("_onlyThisContract: revert")
205+    else true
206+
207+
208+func _whenMultisigSet () = if ((_loadMultisig() == Address(base58'')))
209+    then throw("_whenMultisigSet: revert")
210+    else true
211+
212+
213+func _whenNotInitialized () = if (_loadInit())
214+    then throw("_whenNotInitialized: revert")
215+    else true
216+
217+
218+func _whenInitialized () = if (!(_loadInit()))
219+    then throw("_whenInitialized: revert")
220+    else true
221+
222+
223+func _whenNotPaused () = if (_loadPause())
224+    then throw("_whenNotPaused: revert")
225+    else true
226+
227+
228+func _whenPaused () = if (!(_loadPause()))
229+    then throw("_whenPaused: revert")
230+    else true
231+
232+
233+func _onlyPauser (caller_) = if ((caller_ != _loadPauser()))
234+    then throw("_onlyPauser: revert")
235+    else true
236+
237+
238+func _validateExecutor (val_,err_) = if ((val_ != _loadExecutor()))
239+    then throw(err_)
240+    else true
241+
242+
243+func _validateCallerContract (chainId_,callerContract_,err_) = if ((_loadCallerContract(chainId_) != callerContract_))
244+    then throw(err_)
245+    else true
246+
247+
248+func _chainExists (chainId_,err_) = if ((0 >= size(_loadChain(chainId_))))
249+    then throw(err_)
250+    else true
251+
252+
253+func _assetTickerExists (chainId_,asset_,err_) = if ((0 >= size(_loadAssetTicker(chainId_, asset_))))
254+    then throw(err_)
255+    else true
256+
257+
258+func _validateWavesVault (caller,err_) = if ((_loadWavesVault() != caller))
259+    then throw(err_)
260+    else true
261+
262+
263+@Callable(i)
264+func init (executor_,pauser_,accountStorage_,wavesVault_) = {
265+    let err = if (if (if (if (if (if (_onlyThisContract(i.caller))
266+        then _whenNotInitialized()
267+        else false)
268+        then _whenMultisigSet()
269+        else false)
270+        then _validateAddress(executor_, "init: invalid executor")
271+        else false)
272+        then _validateAddress(pauser_, "init: invalid pauser")
273+        else false)
274+        then _validateAddress(accountStorage_, "init: invalid accountStorage")
275+        else false)
276+        then _validateAddress(wavesVault_, "init: invalid wavesVault")
277+        else false
278+    if ((err == err))
279+        then $Tuple2(((((_saveInit(true) ++ _saveExecutor(addressFromStringValue(executor_))) ++ _savePauser(addressFromStringValue(pauser_))) ++ _saveAccountStorage(addressFromStringValue(accountStorage_))) ++ _saveWavesVault(addressFromStringValue(wavesVault_))), unit)
280+        else throw("Strict value is not equal to itself.")
281+    }
282+
283+
284+
285+@Callable(i)
286+func deposit (callerContract_,from_,to_,chainId_,asset_,amount_) = {
287+    let chainId = valueOrErrorMessage(parseInt(chainId_), "deposit: chainId not int")
288+    let amount = valueOrErrorMessage(parseBigInt(amount_), "deposit: amount not int")
289+    let err = if (if (if (if (if (if (_whenInitialized())
290+        then _whenNotPaused()
291+        else false)
292+        then _chainExists(chainId, "deposit: invalid chainId")
293+        else false)
294+        then _validateString(from_, "deposit: invalid from")
295+        else false)
296+        then _validateString(to_, "deposit: invalid to")
297+        else false)
298+        then _assetTickerExists(chainId, asset_, "deposit: invalid asset")
299+        else false)
300+        then _validateBigInt(amount, ZERO_BIGINT, "deposit: invalid amount")
301+        else false
302+    if ((err == err))
303+        then {
304+            let err1 = if ((_loadChain(chainId) == WAVES))
305+                then _validateWavesVault(i.caller, "deposit: invalid waves vault")
306+                else if (_validateExecutor(i.caller, "deposit: invalid executor"))
307+                    then _validateCallerContract(chainId, callerContract_, "deposit: invalid caller contract")
308+                    else false
309+            if ((err1 == err1))
310+                then {
311+                    let newAssetReserves = (_loadAssetReserves(chainId, asset_) + amount)
312+                    let ticker = _loadAssetTicker(chainId, asset_)
313+                    let newTickerReserves = (_loadTickerReserves(ticker) + amount)
314+                    let invocation = invoke(_loadAccountStorage(), FUNC_DEPOSIT, [to_, SPOT_WALLET, ticker, amount_], nil)
315+                    if ((invocation == invocation))
316+                        then $Tuple2((_saveAssetReserves(chainId, asset_, newAssetReserves) ++ _saveTickerReserves(ticker, newTickerReserves)), unit)
317+                        else throw("Strict value is not equal to itself.")
318+                    }
319+                else throw("Strict value is not equal to itself.")
320+            }
321+        else throw("Strict value is not equal to itself.")
322+    }
323+
324+
325+
326+@Callable(i)
327+func withdraw (from_,to_,chainId_,asset_,amount_,timestamp_,signature_) = $Tuple2(nil, unit)
328+
329+
330+
331+@Callable(i)
332+func requestWithdrawal (from_,to_,chainId_,asset_,amount_,signature_) = $Tuple2(nil, unit)
333+
334+
335+
336+@Callable(i)
337+func executeWithdrawal (from_,to_,chainId_,asset_,amount_,signature_) = $Tuple2(nil, unit)
338+
339+
340+
341+@Callable(i)
342+func addChain (chainId_,name_,callerContract_) = {
343+    let err = if (if (if (if (if (_onlyThisContract(i.caller))
344+        then _whenInitialized()
345+        else false)
346+        then _validateInt(chainId_, 0, MAX_INT, "addChain: invalid chainId")
347+        else false)
348+        then _validateString(name_, "addChain: invalid name")
349+        else false)
350+        then _validateString(callerContract_, "addChain: invalid callerContract")
351+        else false)
352+        then !(_chainExists(chainId_, "addChain: already exists"))
353+        else false
354+    if ((err == err))
355+        then $Tuple2((_saveChain(chainId_, name_) ++ _saveCallerContract(chainId_, callerContract_)), unit)
356+        else throw("Strict value is not equal to itself.")
357+    }
358+
359+
360+
361+@Callable(i)
362+func addAsset (chainId_,asset_,ticker_) = {
363+    let err = if (if (if (if (if (_onlyThisContract(i.caller))
364+        then _whenInitialized()
365+        else false)
366+        then _chainExists(chainId_, "addAsset: invalid chainId")
367+        else false)
368+        then _validateString(asset_, "addAsset: invalid asset")
369+        else false)
370+        then _validateString(ticker_, "addAsset: invalid ticker")
371+        else false)
372+        then !(_assetTickerExists(chainId_, asset_, "addAsset: already exists"))
373+        else false
374+    if ((err == err))
375+        then $Tuple2(_saveAssetTicker(chainId_, asset_, ticker_), unit)
376+        else throw("Strict value is not equal to itself.")
377+    }
378+
379+
380+
381+@Callable(i)
382+func pause () = {
383+    let err = if (if (_onlyPauser(i.caller))
384+        then _whenInitialized()
385+        else false)
386+        then _whenNotPaused()
387+        else false
388+    if ((err == err))
389+        then $Tuple2(_savePause(true), unit)
390+        else throw("Strict value is not equal to itself.")
391+    }
392+
393+
394+
395+@Callable(i)
396+func unpause () = {
397+    let err = if (if (_onlyPauser(i.caller))
398+        then _whenInitialized()
399+        else false)
400+        then _whenPaused()
401+        else false
402+    if ((err == err))
403+        then $Tuple2(_savePause(false), unit)
404+        else throw("Strict value is not equal to itself.")
405+    }
406+
407+
408+
409+@Callable(i)
410+func updatePauser (pauser_) = {
411+    let err = if (if (_onlyThisContract(i.caller))
412+        then _whenInitialized()
413+        else false)
414+        then _validateAddress(pauser_, "updatePauser: invalid pauser")
415+        else false
416+    if ((err == err))
417+        then $Tuple2(_savePauser(addressFromStringValue(pauser_)), unit)
418+        else throw("Strict value is not equal to itself.")
419+    }
420+
421+
422+
423+@Callable(i)
424+func setMultisig (multisig_) = {
425+    let err = if (_onlyThisContract(i.caller))
426+        then _validateAddress(multisig_, "setMultisig: invalid multisig")
427+        else false
428+    if ((err == err))
429+        then $Tuple2(_saveMultisig(addressFromStringValue(multisig_)), unit)
430+        else throw("Strict value is not equal to itself.")
431+    }
432+
433+
434+@Verifier(tx)
435+func verify () = match getString(KEY_MULTISIG) {
436+    case multisig: String => 
437+        valueOrElse(getBoolean(addressFromStringValue(multisig), makeString([KEY_STATUS, toString(this), toBase58String(tx.id)], SEPARATOR)), false)
438+    case _ => 
439+        sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
440+}
441+
github/deemru/w8io/026f985 
24.05 ms ◑