tx · AUoVe8eF3kiGRgqJ2d394w4M2Xej6RYkWEhyteuYbRjF

3Ms7em8i7DYWb6by9VnDECFTejGwZ8guo6P:  -0.01400000 Waves

2023.02.22 22:47 [2461293] smart account 3Ms7em8i7DYWb6by9VnDECFTejGwZ8guo6P > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "AUoVe8eF3kiGRgqJ2d394w4M2Xej6RYkWEhyteuYbRjF",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1677095242874,
    "version": 2,
    "chainId": 84,
    "sender": "3Ms7em8i7DYWb6by9VnDECFTejGwZ8guo6P",
    "senderPublicKey": "4cpUhMagzC8h4aLvvWwCdpcwfhVNRFmpeoG9zBhJZEeJ",
    "proofs": [
        "9zFYeJZWdaBVnTb4J8RyyVxp1eZ1nyWDcpVXq8noVkyfWEo2x38bVGWfA66XdLsgL872mtRE1NCAaLCXFAip15U"
    ],
    "script": "base64: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",
    "height": 2461293,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: 2oMuWvUFBSiHHm5622KH8zKq5TvvAoxMpQiMGgV1SvCJ

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let SEPARATOR = "__"
5+
6+let KEY_INIT = "INIT"
7+
8+let KEY_MULTISIG = "MULTISIG"
9+
10+let KEY_STATUS = "STATUS"
11+
12+let KEY_PAUSED = "PAUSED"
13+
14+let KEY_PAUSER = "PAUSER"
15+
16+let KEY_ROOT_ADAPTER = "ROOT_ADAPTER"
17+
18+let KEY_PROTOCOL_CALLER = "PROTOCOL_CALLER"
19+
20+let KEY_NATIVE_TOKEN_BRIDGE_CONTRACT = "NATIVE_TOKEN_BRIDGE_CONTRACT"
21+
22+let KEY_ERC20_TOKEN_BRIDGE_CONTRACT = "ERC20_TOKEN_BRIDGE_CONTRACT"
23+
24+let FUNC_CALL = "call"
25+
26+let MAX_INT = 9223372036854775807
27+
28+let SLOT_SIZE = 32
29+
30+let ZERO_SLOT = base58'11111111111111111111111111111111'
31+
32+let ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
33+
34+func _validateAddress (address_,err_) = match addressFromString(address_) {
35+    case a: Address => 
36+        true
37+    case _ => 
38+        throw(err_)
39+}
40+
41+
42+func _loadInit () = match getBoolean(KEY_INIT) {
43+    case a: Boolean => 
44+        a
45+    case _ => 
46+        false
47+}
48+
49+
50+func _saveInit (isInit_) = [BooleanEntry(KEY_INIT, isInit_)]
51+
52+
53+func _loadPause () = match getBoolean(KEY_PAUSED) {
54+    case a: Boolean => 
55+        a
56+    case _ => 
57+        false
58+}
59+
60+
61+func _savePause (isPaused_) = [BooleanEntry(KEY_PAUSED, isPaused_)]
62+
63+
64+func _loadPauser () = match getString(KEY_PAUSER) {
65+    case a: String => 
66+        addressFromStringValue(a)
67+    case _ => 
68+        Address(base58'')
69+}
70+
71+
72+func _savePauser (pauser_) = [StringEntry(KEY_PAUSER, toString(pauser_))]
73+
74+
75+func _loadMultisig () = match getString(KEY_MULTISIG) {
76+    case a: String => 
77+        addressFromStringValue(a)
78+    case _ => 
79+        Address(base58'')
80+}
81+
82+
83+func _saveMultisig (multisig_) = [StringEntry(KEY_MULTISIG, toString(multisig_))]
84+
85+
86+func _loadRootAdapter () = match getString(KEY_ROOT_ADAPTER) {
87+    case a: String => 
88+        addressFromStringValue(a)
89+    case _ => 
90+        Address(base58'')
91+}
92+
93+
94+func _saveRootAdapter (adapter_) = [StringEntry(KEY_ROOT_ADAPTER, toString(adapter_))]
95+
96+
97+func _loadProtocolCaller () = match getString(KEY_PROTOCOL_CALLER) {
98+    case a: String => 
99+        addressFromStringValue(a)
100+    case _ => 
101+        Address(base58'')
102+}
103+
104+
105+func _saveProtocolCaller (caller_) = [StringEntry(KEY_PROTOCOL_CALLER, toString(caller_))]
106+
107+
108+func _loadNativeTokenBridgeContract () = match getString(KEY_NATIVE_TOKEN_BRIDGE_CONTRACT) {
109+    case a: String => 
110+        a
111+    case _ => 
112+        ""
113+}
114+
115+
116+func _saveNativeTokenBridgeContract (contract_) = [StringEntry(KEY_NATIVE_TOKEN_BRIDGE_CONTRACT, contract_)]
117+
118+
119+func _loadERC20TokenBridgeContract () = match getString(KEY_ERC20_TOKEN_BRIDGE_CONTRACT) {
120+    case a: String => 
121+        a
122+    case _ => 
123+        ""
124+}
125+
126+
127+func _saveERC20TokenBridgeContract (contract_) = [StringEntry(KEY_ERC20_TOKEN_BRIDGE_CONTRACT, contract_)]
128+
129+
130+func _onlyThisContract (caller_) = if ((caller_ != this))
131+    then throw("_onlyThisContract: revert")
132+    else true
133+
134+
135+func _whenMultisigSet () = if ((_loadMultisig() == Address(base58'')))
136+    then throw("_whenMultisigSet: revert")
137+    else true
138+
139+
140+func _whenNotInitialized () = if (_loadInit())
141+    then throw("_whenNotInitialized: revert")
142+    else true
143+
144+
145+func _whenInitialized () = if (!(_loadInit()))
146+    then throw("_whenInitialized: revert")
147+    else true
148+
149+
150+func _whenNotPaused () = if (_loadPause())
151+    then throw("_whenNotPaused: revert")
152+    else true
153+
154+
155+func _whenPaused () = if (!(_loadPause()))
156+    then throw("_whenPaused: revert")
157+    else true
158+
159+
160+func _onlyPauser (caller_) = if ((caller_ != _loadPauser()))
161+    then throw("_onlyPauser: revert")
162+    else true
163+
164+
165+func _isRootAdapter (caller_) = if ((_loadRootAdapter() != caller_))
166+    then throw("_isRootAdapter: revert")
167+    else true
168+
169+
170+func _alignLeft (val_) = (val_ + take(ZERO_SLOT, (SLOT_SIZE - size(val_))))
171+
172+
173+func _alignRight (val_) = (take(ZERO_SLOT, (SLOT_SIZE - size(val_))) + val_)
174+
175+
176+@Callable(i)
177+func init (protocolCaller_,rootAdapter_,pauser_) = {
178+    let err = if (if (if (if (if (_onlyThisContract(i.caller))
179+        then _whenNotInitialized()
180+        else false)
181+        then _whenMultisigSet()
182+        else false)
183+        then _validateAddress(protocolCaller_, "init: invalid protocolCaller")
184+        else false)
185+        then _validateAddress(rootAdapter_, "init: invalid rootAdapter")
186+        else false)
187+        then _validateAddress(pauser_, "init: invalid pauser")
188+        else false
189+    if ((err == err))
190+        then $Tuple2((((_saveInit(true) ++ _saveProtocolCaller(addressFromStringValue(protocolCaller_))) ++ _saveRootAdapter(addressFromStringValue(rootAdapter_))) ++ _savePauser(addressFromStringValue(pauser_))), unit)
191+        else throw("Strict value is not equal to itself.")
192+    }
193+
194+
195+
196+@Callable(i)
197+func releaseTokens (executionChainId_,executionAsset_,amount_,recipient_,gaslessReward_) = {
198+    let err = if (if (_whenInitialized())
199+        then _whenNotPaused()
200+        else false)
201+        then _isRootAdapter(i.caller)
202+        else false
203+    if ((err == err))
204+        then {
205+            let executionAssetBytes = _alignRight(fromBase16String(drop(executionAsset_, 2)))
206+            let recipientBytes = _alignRight(fromBase16String(drop(recipient_, 2)))
207+            let amountBytes = _alignRight(toBytes(amount_))
208+            let gaslessRewardBytes = _alignRight(toBytes(gaslessReward_))
209+            let callArgs = if ((executionAsset_ == ZERO_ADDRESS))
210+                then $Tuple2(_loadNativeTokenBridgeContract(), ("0x" + toBase16String(((((base58'2SGoDjnzW' + ZERO_SLOT) + recipientBytes) + amountBytes) + gaslessRewardBytes))))
211+                else $Tuple2(_loadERC20TokenBridgeContract(), ("0x" + toBase16String((((((base58'n2cEoAN6' + ZERO_SLOT) + executionAssetBytes) + recipientBytes) + amountBytes) + gaslessRewardBytes))))
212+            let invocation = invoke(_loadProtocolCaller(), FUNC_CALL, [executionChainId_, callArgs._1, callArgs._2], nil)
213+            if ((invocation == invocation))
214+                then $Tuple2(nil, unit)
215+                else throw("Strict value is not equal to itself.")
216+            }
217+        else throw("Strict value is not equal to itself.")
218+    }
219+
220+
221+
222+@Callable(i)
223+func setNativeTokenBridgeContract (contract_) = {
224+    let err = if (_onlyThisContract(i.caller))
225+        then _whenInitialized()
226+        else false
227+    if ((err == err))
228+        then $Tuple2(_saveNativeTokenBridgeContract(contract_), unit)
229+        else throw("Strict value is not equal to itself.")
230+    }
231+
232+
233+
234+@Callable(i)
235+func setERC20TokenBridgeContract (contract_) = {
236+    let err = if (_onlyThisContract(i.caller))
237+        then _whenInitialized()
238+        else false
239+    if ((err == err))
240+        then $Tuple2(_saveERC20TokenBridgeContract(contract_), unit)
241+        else throw("Strict value is not equal to itself.")
242+    }
243+
244+
245+
246+@Callable(i)
247+func pause () = {
248+    let err = if (if (_onlyPauser(i.caller))
249+        then _whenInitialized()
250+        else false)
251+        then _whenNotPaused()
252+        else false
253+    if ((err == err))
254+        then $Tuple2(_savePause(true), unit)
255+        else throw("Strict value is not equal to itself.")
256+    }
257+
258+
259+
260+@Callable(i)
261+func unpause () = {
262+    let err = if (if (_onlyPauser(i.caller))
263+        then _whenInitialized()
264+        else false)
265+        then _whenPaused()
266+        else false
267+    if ((err == err))
268+        then $Tuple2(_savePause(false), unit)
269+        else throw("Strict value is not equal to itself.")
270+    }
271+
272+
273+
274+@Callable(i)
275+func updatePauser (pauser_) = {
276+    let err = if (if (_onlyThisContract(i.caller))
277+        then _whenInitialized()
278+        else false)
279+        then _validateAddress(pauser_, "init: invalid pauser")
280+        else false
281+    if ((err == err))
282+        then $Tuple2(_savePauser(addressFromStringValue(pauser_)), unit)
283+        else throw("Strict value is not equal to itself.")
284+    }
285+
286+
287+
288+@Callable(i)
289+func setMultisig (multisig_) = {
290+    let err = if (_onlyThisContract(i.caller))
291+        then _validateAddress(multisig_, "setMultisig: invalid multisig")
292+        else false
293+    if ((err == err))
294+        then $Tuple2(_saveMultisig(addressFromStringValue(multisig_)), unit)
295+        else throw("Strict value is not equal to itself.")
296+    }
297+
298+
299+@Verifier(tx)
300+func verify () = match getString(KEY_MULTISIG) {
301+    case multisig: String => 
302+        valueOrElse(getBoolean(addressFromStringValue(multisig), makeString([KEY_STATUS, toString(this), toBase58String(tx.id)], SEPARATOR)), false)
303+    case _ => 
304+        sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
305+}
306+
github/deemru/w8io/169f3d6 
66.58 ms ◑