tx · HhLmRNBtyHTQyzdkatBcYAFqEkawcmMFykXyeUQfVQpd

3MpiUwTkYopBwQEjyTf8sqy7iWLNwyq9Md4:  -0.01800000 Waves

2024.07.04 11:03 [3179005] smart account 3MpiUwTkYopBwQEjyTf8sqy7iWLNwyq9Md4 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "HhLmRNBtyHTQyzdkatBcYAFqEkawcmMFykXyeUQfVQpd",
    "fee": 1800000,
    "feeAssetId": null,
    "timestamp": 1720080218023,
    "version": 2,
    "chainId": 84,
    "sender": "3MpiUwTkYopBwQEjyTf8sqy7iWLNwyq9Md4",
    "senderPublicKey": "9eCupW2UoCBhmiF1N9qWACCzkWT885DVzb65b8zxcSii",
    "proofs": [
        "zWy5Wo6c69wyzUCui2QzNiwDbxeDGi6DJgdF1Kwo3JzHB2JB3CfoEDiVUF7FXMUCey6fpcw1KzkzzjDzUhtBpZh"
    ],
    "script": "base64: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",
    "height": 3179005,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: FQi5iBpKorRvf6vjMgJwf5hwCYC9sPPCHSY6tXNi5q2T

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_SEQUENCER = "SEQUENCER"
13+
14+let KEY_ACCOUNT_STORAGE = "ACCOUNT_STORAGE"
15+
16+let KEY_FEE_RECIPIENT = "FEE_RECIPIENT"
17+
18+let KEY_SYMBOL = "SYMBOL"
19+
20+let KEY_ORDER_FILLED_AMOUNT = "ORDER_FILLED_AMOUNT"
21+
22+let KEY_REWARD_DISTRIBUTOR = "REWARD_DISTRIBUTOR"
23+
24+let FUNC_EXTERNAL_TRANSFER = "externalTransfer"
25+
26+let FUNC_CLAIM_REWARD = "claimReward"
27+
28+let SPOT_WALLET = "SPOT"
29+
30+let ORDER_TYPE_LIMIT = 1
31+
32+let ORDER_TYPE_MARKET = 2
33+
34+let ORDER_VERSION_1 = 1
35+
36+let ORDER_SIDE_BUY = 1
37+
38+let ORDER_SIDE_SELL = 2
39+
40+let ALG_TYPE_WAVES = 1
41+
42+let ALG_TYPE_EVM = 2
43+
44+let ZERO_BIGINT = toBigInt(0)
45+
46+let ONE_BIGINT = toBigInt(1)
47+
48+let MULTIPLIER = toBigInt(100000000)
49+
50+let FEE_MAX_TOLERANCE = toBigInt(100000)
51+
52+let EVM_PREFIX = base58'G5Nu92G2p7moXW9qjjN3na7gtq4dWCeVdaSjry'
53+
54+func _validateAddress (address_,err_) = match addressFromString(address_) {
55+    case a: Address => 
56+        true
57+    case _ => 
58+        throw(err_)
59+}
60+
61+
62+func _validateBigInt (val_,lowerBoundary_,err_) = if ((lowerBoundary_ > val_))
63+    then throw(err_)
64+    else true
65+
66+
67+func _validateIntEqual (val1_,val2_,err_) = if ((val1_ != val2_))
68+    then throw(err_)
69+    else true
70+
71+
72+func _validateIntNotEqual (val1_,val2_,err_) = if ((val1_ == val2_))
73+    then throw(err_)
74+    else true
75+
76+
77+func _validateString (val_,err_) = if (if ((0 >= size(val_)))
78+    then true
79+    else contains(val_, SEPARATOR))
80+    then throw(err_)
81+    else true
82+
83+
84+func _validateStringEqual (val1_,val2_,err_) = if ((val1_ != val2_))
85+    then throw(err_)
86+    else true
87+
88+
89+func _loadInit () = match getBoolean(KEY_INIT) {
90+    case a: Boolean => 
91+        a
92+    case _ => 
93+        false
94+}
95+
96+
97+func _saveInit (isInit_) = [BooleanEntry(KEY_INIT, isInit_)]
98+
99+
100+func _loadMultisig () = match getString(KEY_MULTISIG) {
101+    case a: String => 
102+        addressFromStringValue(a)
103+    case _ => 
104+        Address(base58'')
105+}
106+
107+
108+func _saveMultisig (multisig_) = [StringEntry(KEY_MULTISIG, toString(multisig_))]
109+
110+
111+func _loadSequencer () = match getString(KEY_SEQUENCER) {
112+    case a: String => 
113+        addressFromStringValue(a)
114+    case _ => 
115+        Address(base58'')
116+}
117+
118+
119+func _saveSequencer (sequencer_) = [StringEntry(KEY_SEQUENCER, toString(sequencer_))]
120+
121+
122+func _loadAccountStorage () = match getString(KEY_ACCOUNT_STORAGE) {
123+    case a: String => 
124+        addressFromStringValue(a)
125+    case _ => 
126+        Address(base58'')
127+}
128+
129+
130+func _saveAccountStorage (accountStorage_) = [StringEntry(KEY_ACCOUNT_STORAGE, toString(accountStorage_))]
131+
132+
133+func _loadFeeRecipient () = match getString(KEY_FEE_RECIPIENT) {
134+    case a: String => 
135+        a
136+    case _ => 
137+        ""
138+}
139+
140+
141+func _saveFeeRecipient (feeRecipient_) = [StringEntry(KEY_FEE_RECIPIENT, feeRecipient_)]
142+
143+
144+func _loadRewardDistributor () = match getString(KEY_REWARD_DISTRIBUTOR) {
145+    case a: String => 
146+        a
147+    case _ => 
148+        ""
149+}
150+
151+
152+func _saveRewardDistributor (distributor_) = [StringEntry(KEY_REWARD_DISTRIBUTOR, distributor_)]
153+
154+
155+func _loadSymbol (symbol_) = match getBoolean(makeString([KEY_SYMBOL, symbol_], SEPARATOR)) {
156+    case a: Boolean => 
157+        a
158+    case _ => 
159+        false
160+}
161+
162+
163+func _saveSymbol (symbol_,val_) = [BooleanEntry(makeString([KEY_SYMBOL, symbol_], SEPARATOR), val_)]
164+
165+
166+func _loadOrderFilledAmount (orderHash_) = match getString(makeString([KEY_ORDER_FILLED_AMOUNT, toBase58String(orderHash_)], SEPARATOR)) {
167+    case a: String => 
168+        parseBigIntValue(a)
169+    case _ => 
170+        ZERO_BIGINT
171+}
172+
173+
174+func _saveOrderFilledAmount (orderHash_,amount_) = [StringEntry(makeString([KEY_ORDER_FILLED_AMOUNT, toBase58String(orderHash_)], SEPARATOR), toString(amount_))]
175+
176+
177+func _onlyThisContract (caller_) = if ((caller_ != this))
178+    then throw("_onlyThisContract: revert")
179+    else true
180+
181+
182+func _whenMultisigSet () = if ((_loadMultisig() == Address(base58'')))
183+    then throw("_whenMultisigSet: revert")
184+    else true
185+
186+
187+func _whenNotInitialized () = if (_loadInit())
188+    then throw("_whenNotInitialized: revert")
189+    else true
190+
191+
192+func _whenInitialized () = if (!(_loadInit()))
193+    then throw("_whenInitialized: revert")
194+    else true
195+
196+
197+func _validateSequencer (caller,err_) = if ((_loadSequencer() != caller))
198+    then throw(err_)
199+    else true
200+
201+
202+func _validateOrderType (type_,version_,err_) = if (if ((type_ != ORDER_TYPE_LIMIT))
203+    then (type_ != ORDER_TYPE_MARKET)
204+    else false)
205+    then throw(err_)
206+    else if ((version_ != ORDER_VERSION_1))
207+        then throw(err_)
208+        else true
209+
210+
211+func _validateOrderSymbol (symbol_,err_) = if (!(_loadSymbol(symbol_)))
212+    then throw(err_)
213+    else true
214+
215+
216+func _validateOrderSide (side_,err_) = if (if ((side_ != ORDER_SIDE_BUY))
217+    then (side_ != ORDER_SIDE_SELL)
218+    else false)
219+    then throw(err_)
220+    else true
221+
222+
223+func _validateOrderPrices (makerOrderPrice_,takerOrderPrice_,takerOrderSide_,takerOrderType_,err_) = {
224+    let result = if ((takerOrderType_ == ORDER_TYPE_MARKET))
225+        then true
226+        else if ((takerOrderSide_ == ORDER_SIDE_BUY))
227+            then (takerOrderPrice_ >= makerOrderPrice_)
228+            else if ((takerOrderSide_ == ORDER_SIDE_SELL))
229+                then (makerOrderPrice_ >= takerOrderPrice_)
230+                else false
231+    if (!(result))
232+        then throw(err_)
233+        else true
234+    }
235+
236+
237+func _validateSignatureFormat (signature_,alg_,err_) = if ((alg_ == ALG_TYPE_WAVES))
238+    then if ((size(signature_) != 64))
239+        then throw(err_)
240+        else true
241+    else if ((alg_ == ALG_TYPE_EVM))
242+        then if ((size(signature_) != 65))
243+            then throw(err_)
244+            else true
245+        else throw((err_ + ": inv alg"))
246+
247+
248+func _validatePublicKey (publicKey_,alg_,err_) = if ((alg_ == ALG_TYPE_WAVES))
249+    then if ((size(publicKey_) != 32))
250+        then throw(err_)
251+        else true
252+    else if ((alg_ == ALG_TYPE_EVM))
253+        then if ((size(publicKey_) != 20))
254+            then throw(err_)
255+            else true
256+        else throw((err_ + ": inv alg"))
257+
258+
259+func _convertPublicKeyToAddress (publicKey_,alg_) = if ((alg_ == ALG_TYPE_WAVES))
260+    then toString(addressFromPublicKey(publicKey_))
261+    else if ((alg_ == ALG_TYPE_EVM))
262+        then ("0x" + toBase16String(publicKey_))
263+        else throw("_convertPublicKeyToAddress: revert")
264+
265+
266+func _validateOrderSignature (orderHash_,signature_,publicKey_,alg_,err_) = {
267+    let result = if ((alg_ == ALG_TYPE_WAVES))
268+        then sigVerify(orderHash_, signature_, publicKey_)
269+        else if ((alg_ == ALG_TYPE_EVM))
270+            then {
271+                let hashWithPrefix = keccak256_16Kb((EVM_PREFIX + orderHash_))
272+                (takeRight(keccak256_16Kb(ecrecover(hashWithPrefix, signature_)), 20) == publicKey_)
273+                }
274+            else throw((err_ + ": inv alg"))
275+    if (!(result))
276+        then throw(err_)
277+        else true
278+    }
279+
280+
281+func _validateFeeTolerance (amount_,fee_,err_) = if ((fee_ > fraction(amount_, FEE_MAX_TOLERANCE, MULTIPLIER, DOWN)))
282+    then throw(err_)
283+    else true
284+
285+
286+func _parseOrder (order_,err_) = {
287+    let fields = split(order_, SEPARATOR)
288+    let type = valueOrErrorMessage(parseInt(fields[0]), (err_ + ": inv type"))
289+    let version = valueOrErrorMessage(parseInt(fields[1]), (err_ + ": inv version"))
290+    let symbol = fields[2]
291+    let side = valueOrErrorMessage(parseInt(fields[3]), (err_ + ": inv side"))
292+    let ts = valueOrErrorMessage(parseInt(fields[4]), (err_ + ": inv ts"))
293+    let publicKey = fromBase58String(fields[5])
294+    let alg = valueOrErrorMessage(parseInt(fields[6]), (err_ + ": inv alg"))
295+    let signature = fromBase58String(fields[7])
296+    let $t083579395 = if (if ((type == ORDER_TYPE_LIMIT))
297+        then (version == ORDER_VERSION_1)
298+        else false)
299+        then {
300+            let price = valueOrErrorMessage(parseBigInt(fields[8]), (err_ + ": inv price"))
301+            let amount = valueOrErrorMessage(parseBigInt(fields[9]), (err_ + ": inv amount"))
302+            let orderDetailsBytes = (toBytes(price) + toBytes(amount))
303+            $Tuple4(price, amount, ZERO_BIGINT, orderDetailsBytes)
304+            }
305+        else if (if ((type == ORDER_TYPE_MARKET))
306+            then (version == ORDER_VERSION_1)
307+            else false)
308+            then {
309+                let amount = valueOrErrorMessage(parseBigInt(fields[8]), (err_ + ": inv amount"))
310+                let isBaseAmount = if ((valueOrErrorMessage(parseBigInt(fields[9]), (err_ + ": inv isBaseAmount")) == ZERO_BIGINT))
311+                    then false
312+                    else true
313+                if (isBaseAmount)
314+                    then $Tuple4(ZERO_BIGINT, amount, ZERO_BIGINT, (toBytes(amount) + toBytes(ONE_BIGINT)))
315+                    else $Tuple4(ZERO_BIGINT, ZERO_BIGINT, amount, (toBytes(amount) + toBytes(ZERO_BIGINT)))
316+                }
317+            else throw((err_ + ": inv type & version"))
318+    let price = $t083579395._1
319+    let baseAmount = $t083579395._2
320+    let quoteAmount = $t083579395._3
321+    let orderDetailsBytes = $t083579395._4
322+    let orderBytes = ((((((((toBytes(type) + toBytes(version)) + toBytes(size(symbol))) + toBytes(symbol)) + toBytes(side)) + toBytes(ts)) + publicKey) + toBytes(alg)) + orderDetailsBytes)
323+    let orderHash = keccak256_32Kb(orderBytes)
324+    let err = if (if (if (if (if (if (if (_validateOrderType(type, version, (err_ + ": inv order type")))
325+        then _validateOrderSymbol(symbol, (err_ + ": inv order symbol"))
326+        else false)
327+        then _validateOrderSide(side, (err_ + ": inv order side"))
328+        else false)
329+        then _validatePublicKey(publicKey, alg, (err_ + ": inv order public key"))
330+        else false)
331+        then _validateSignatureFormat(signature, alg, (err_ + ": inv sig format"))
332+        else false)
333+        then _validateBigInt(price, ZERO_BIGINT, (err_ + ": neg price"))
334+        else false)
335+        then _validateBigInt(baseAmount, ZERO_BIGINT, (err_ + ": neg base amount"))
336+        else false)
337+        then _validateBigInt(quoteAmount, ZERO_BIGINT, (err_ + ": neg quote amount"))
338+        else false
339+    if ((err == err))
340+        then $Tuple10(type, symbol, side, price, baseAmount, quoteAmount, orderHash, publicKey, alg, signature)
341+        else throw("Strict value is not equal to itself.")
342+    }
343+
344+
345+@Callable(i)
346+func init (sequencer_,accountStorage_,feeRecipient_) = {
347+    let err = if (if (if (if (if (_onlyThisContract(i.caller))
348+        then _whenNotInitialized()
349+        else false)
350+        then _whenMultisigSet()
351+        else false)
352+        then _validateAddress(sequencer_, "init: invalid sequencer")
353+        else false)
354+        then _validateAddress(accountStorage_, "init: invalid accountStorage")
355+        else false)
356+        then _validateString(feeRecipient_, "init: invalid feeRecipient")
357+        else false
358+    if ((err == err))
359+        then $Tuple2((((_saveInit(true) ++ _saveSequencer(addressFromStringValue(sequencer_))) ++ _saveAccountStorage(addressFromStringValue(accountStorage_))) ++ _saveFeeRecipient(feeRecipient_)), unit)
360+        else throw("Strict value is not equal to itself.")
361+    }
362+
363+
364+
365+@Callable(i)
366+func trade (makerOrder_,takerOrder_,baseFee_,quoteFee_) = {
367+    let $t01122711559 = _parseOrder(makerOrder_, "trade: invalid maker order")
368+    let makerOrderType = $t01122711559._1
369+    let makerOrderSymbol = $t01122711559._2
370+    let makerOrderSide = $t01122711559._3
371+    let makerOrderPrice = $t01122711559._4
372+    let makerOrderBaseAmount = $t01122711559._5
373+    let makerOrderQuoteAmount = $t01122711559._6
374+    let makerOrderHash = $t01122711559._7
375+    let makerOrderPublicKey = $t01122711559._8
376+    let makerOrderAlg = $t01122711559._9
377+    let makerOrderSignature = $t01122711559._10
378+    let $t01156511897 = _parseOrder(takerOrder_, "trade: invalid taker order")
379+    let takerOrderType = $t01156511897._1
380+    let takerOrderSymbol = $t01156511897._2
381+    let takerOrderSide = $t01156511897._3
382+    let takerOrderPrice = $t01156511897._4
383+    let takerOrderBaseAmount = $t01156511897._5
384+    let takerOrderQuoteAmount = $t01156511897._6
385+    let takerOrderHash = $t01156511897._7
386+    let takerOrderPublicKey = $t01156511897._8
387+    let takerOrderAlg = $t01156511897._9
388+    let takerOrderSignature = $t01156511897._10
389+    let baseFee = valueOrErrorMessage(parseBigInt(baseFee_), "trade: baseFee not int")
390+    let quoteFee = valueOrErrorMessage(parseBigInt(quoteFee_), "trade: quoteFee not int")
391+    let tradePrice = makerOrderPrice
392+    let makerOrderFilledAmount = _loadOrderFilledAmount(makerOrderHash)
393+    let makerOrderBaseAmountFree = (makerOrderBaseAmount - makerOrderFilledAmount)
394+    let takerOrderFilledAmount = _loadOrderFilledAmount(takerOrderHash)
395+    let takerOrderBaseAmountFree = if ((takerOrderBaseAmount == ZERO_BIGINT))
396+        then fraction((takerOrderQuoteAmount - takerOrderFilledAmount), MULTIPLIER, tradePrice, DOWN)
397+        else (takerOrderBaseAmount - takerOrderFilledAmount)
398+    let tradeBaseAmount = min([makerOrderBaseAmountFree, takerOrderBaseAmountFree])
399+    let tradeQuoteAmount = fraction(tradeBaseAmount, tradePrice, MULTIPLIER, DOWN)
400+    let err = if (if (if (if (if (if (if (if (if (_validateSequencer(i.caller, "trade: invalid sequencer"))
401+        then _validateBigInt(tradeBaseAmount, ZERO_BIGINT, "trade: neg trade amount")
402+        else false)
403+        then _validateIntEqual(makerOrderType, ORDER_TYPE_LIMIT, "trade: maker is not limit")
404+        else false)
405+        then _validateStringEqual(makerOrderSymbol, takerOrderSymbol, "trade: symbol mismatch")
406+        else false)
407+        then _validateIntNotEqual(makerOrderSide, takerOrderSide, "trade: side mismatch")
408+        else false)
409+        then _validateOrderSignature(makerOrderHash, makerOrderSignature, makerOrderPublicKey, makerOrderAlg, "trade: invalid maker sig")
410+        else false)
411+        then _validateOrderSignature(takerOrderHash, takerOrderSignature, takerOrderPublicKey, takerOrderAlg, "trade: invalid taker sig")
412+        else false)
413+        then _validateFeeTolerance(tradeBaseAmount, baseFee, "trade: base fee too much")
414+        else false)
415+        then _validateFeeTolerance(tradeQuoteAmount, quoteFee, "trade: quote fee too much")
416+        else false)
417+        then _validateOrderPrices(makerOrderPrice, takerOrderPrice, takerOrderSide, takerOrderType, "trade: prices mismatch")
418+        else false
419+    if ((err == err))
420+        then {
421+            let makerAddress = _convertPublicKeyToAddress(makerOrderPublicKey, makerOrderAlg)
422+            let takerAddress = _convertPublicKeyToAddress(takerOrderPublicKey, takerOrderAlg)
423+            let $t01407214495 = if ((makerOrderSide == ORDER_SIDE_BUY))
424+                then $Tuple2(makerAddress, takerAddress)
425+                else $Tuple2(takerAddress, makerAddress)
426+            let buyer = $t01407214495._1
427+            let seller = $t01407214495._2
428+            let assets = split(makerOrderSymbol, "-")
429+            let baseAsset = assets[0]
430+            let quoteAsset = assets[1]
431+            let feeRecipient = _loadFeeRecipient()
432+            let storageInvocation = invoke(_loadAccountStorage(), FUNC_EXTERNAL_TRANSFER, [SPOT_WALLET, baseAsset, seller, buyer, toString(tradeBaseAmount), toString(baseFee), feeRecipient], nil)
433+            if ((storageInvocation == storageInvocation))
434+                then {
435+                    let storageInvocation1 = invoke(_loadAccountStorage(), FUNC_EXTERNAL_TRANSFER, [SPOT_WALLET, quoteAsset, buyer, seller, toString(tradeQuoteAmount), toString(quoteFee), feeRecipient], nil)
436+                    if ((storageInvocation1 == storageInvocation1))
437+                        then {
438+                            let newMakerOrderFilledAmount = (makerOrderFilledAmount + tradeBaseAmount)
439+                            let newTakerOrderFilledAmount = if ((takerOrderBaseAmount == ZERO_BIGINT))
440+                                then (takerOrderFilledAmount + tradeQuoteAmount)
441+                                else (takerOrderFilledAmount + tradeBaseAmount)
442+                            $Tuple2((_saveOrderFilledAmount(makerOrderHash, newMakerOrderFilledAmount) ++ _saveOrderFilledAmount(takerOrderHash, newTakerOrderFilledAmount)), unit)
443+                            }
444+                        else throw("Strict value is not equal to itself.")
445+                    }
446+                else throw("Strict value is not equal to itself.")
447+            }
448+        else throw("Strict value is not equal to itself.")
449+    }
450+
451+
452+
453+@Callable(i)
454+func claimReward (user_,currency_,amount_) = {
455+    let amount = valueOrErrorMessage(parseBigInt(amount_), "claimReward: amount not int")
456+    let err = if (if (if (_validateSequencer(i.caller, "claimReward: invalid sequencer"))
457+        then _validateString(user_, "claimReward: invalid user")
458+        else false)
459+        then _validateString(currency_, "claimReward: invalid currency")
460+        else false)
461+        then _validateBigInt(amount, ZERO_BIGINT, "claimReward: neg amount")
462+        else false
463+    if ((err == err))
464+        then {
465+            let storageInvocation = invoke(_loadAccountStorage(), FUNC_CLAIM_REWARD, [_loadRewardDistributor(), user_, currency_, amount_], nil)
466+            if ((storageInvocation == storageInvocation))
467+                then $Tuple2(nil, unit)
468+                else throw("Strict value is not equal to itself.")
469+            }
470+        else throw("Strict value is not equal to itself.")
471+    }
472+
473+
474+
475+@Callable(i)
476+func updateSymbol (symbol_,allowance_) = {
477+    let err = if (_onlyThisContract(i.caller))
478+        then _validateString(symbol_, "updateSymbol: invalid symbol")
479+        else false
480+    if ((err == err))
481+        then $Tuple2(_saveSymbol(symbol_, allowance_), unit)
482+        else throw("Strict value is not equal to itself.")
483+    }
484+
485+
486+
487+@Callable(i)
488+func updateFeeRecipient (feeRecipient_) = {
489+    let err = if (if (_onlyThisContract(i.caller))
490+        then _whenInitialized()
491+        else false)
492+        then _validateString(feeRecipient_, "updateFeeRecipient: invalid feeRecipient")
493+        else false
494+    if ((err == err))
495+        then $Tuple2(_saveFeeRecipient(feeRecipient_), unit)
496+        else throw("Strict value is not equal to itself.")
497+    }
498+
499+
500+
501+@Callable(i)
502+func updateRewardDistributor (rewardDistributor_) = {
503+    let err = if (if (_onlyThisContract(i.caller))
504+        then _whenInitialized()
505+        else false)
506+        then _validateString(rewardDistributor_, "updateRewardDistributor: invalid rewardDistributor")
507+        else false
508+    if ((err == err))
509+        then $Tuple2(_saveRewardDistributor(rewardDistributor_), unit)
510+        else throw("Strict value is not equal to itself.")
511+    }
512+
513+
514+
515+@Callable(i)
516+func setMultisig (multisig_) = {
517+    let err = if (_onlyThisContract(i.caller))
518+        then _validateAddress(multisig_, "setMultisig: invalid multisig")
519+        else false
520+    if ((err == err))
521+        then $Tuple2(_saveMultisig(addressFromStringValue(multisig_)), unit)
522+        else throw("Strict value is not equal to itself.")
523+    }
524+
525+
526+@Verifier(tx)
527+func verify () = match getString(KEY_MULTISIG) {
528+    case multisig: String => 
529+        valueOrElse(getBoolean(addressFromStringValue(multisig), makeString([KEY_STATUS, toString(this), toBase58String(tx.id)], SEPARATOR)), false)
530+    case _ => 
531+        sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
532+}
533+
github/deemru/w8io/169f3d6 
36.05 ms ◑