tx · 5UZpAdzRdnE8NNLnMoucXr3ArD9P112wskTZLCiyabpk

3N4vPEuMkXveuFYFohFsZaPMdbbiP24T1F7:  -0.01000000 Waves

2023.09.06 17:28 [2743632] smart account 3N4vPEuMkXveuFYFohFsZaPMdbbiP24T1F7 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "5UZpAdzRdnE8NNLnMoucXr3ArD9P112wskTZLCiyabpk",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1694010518506,
    "version": 2,
    "chainId": 84,
    "sender": "3N4vPEuMkXveuFYFohFsZaPMdbbiP24T1F7",
    "senderPublicKey": "2paZxKSEp48rdM6xb5j15ZN3hHbBLxSQmsuG1HnK5sPp",
    "proofs": [
        "45o8M5hskjXxtrNtH8BoYxCsq7s64w5GY8mVCJtKYExgcpqc7PLQefgHVEpeGJAYnYWv8kKnve7F6gWtpmvZTyGN"
    ],
    "script": "base64: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",
    "height": 2743632,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: FRQoNFT4ZazKBrfqNZEoa8zF8UVVrAPZ2C6JMwa1oGif

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 5 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let currentLockIdKey = "currentLockId"
5+
6+let adminContractKey = "adminContract"
7+
8+let treasuryContractKey = "treasuryContract"
9+
10+let isFreezedKey = "isFreezed"
11+
12+let isConstructedKey = "isConstructed"
13+
14+let verifiersKey = "verifiers"
15+
16+let verifiersDataKey = "verifiersData"
17+
18+let unlockFeeBasisKey = "unlockFeeBasis"
19+
20+let SEP = "__"
21+
22+let MULT10 = 10000000000
23+
24+func asPayment (v) = match v {
25+    case p: AttachedPayment => 
26+        p
27+    case _ => 
28+        throw("fail to cast into AttachedPayment")
29+}
30+
31+
32+func asByteVector (v) = match v {
33+    case p: ByteVector => 
34+        p
35+    case _ => 
36+        throw("fail to cast into ByteVector")
37+}
38+
39+
40+func maxTakeableAmount (lockHeight,vestingPeriod,amount,takedAmount) = {
41+    let blocksPassed = (height - lockHeight)
42+    if ((blocksPassed >= vestingPeriod))
43+        then (amount - takedAmount)
44+        else {
45+            let perBlockUnlock = fraction(amount, MULT10, vestingPeriod, HALFUP)
46+            let availableUnlock = fraction(perBlockUnlock, blocksPassed, MULT10)
47+            (availableUnlock - takedAmount)
48+            }
49+    }
50+
51+
52+func treasuryAmount (amount) = {
53+    let feeBasis = getIntegerValue(unlockFeeBasisKey)
54+    if ((feeBasis == 0))
55+        then 0
56+        else fraction(fraction(amount, MULT10, 1000, HALFUP), feeBasis, MULT10, HALFUP)
57+    }
58+
59+
60+@Callable(i)
61+func constructor (adminAdress,unlockFeeBasis,treasuryContract,verifiers,requiredVerifiers) = if (isDefined(getBoolean(isConstructedKey)))
62+    then throw("Constructor can be called just once")
63+    else {
64+        let verifiersCount = size(verifiers)
65+        if ((verifiersCount > 8))
66+            then throw("Max verifiers number is 8")
67+            else {
68+                let verifiersPubKeys = makeString(verifiers, SEP)
69+[StringEntry(adminContractKey, adminAdress), IntegerEntry(currentLockIdKey, 0), BooleanEntry(isFreezedKey, false), BooleanEntry(isConstructedKey, true), IntegerEntry(unlockFeeBasisKey, unlockFeeBasis), StringEntry(treasuryContractKey, treasuryContract), StringEntry(verifiersKey, verifiersPubKeys), StringEntry(verifiersDataKey, ((toString(verifiersCount) + SEP) + toString(requiredVerifiers)))]
70+                }
71+        }
72+
73+
74+
75+@Callable(i)
76+func lock (period) = if (getBooleanValue(isFreezedKey))
77+    then throw("Contract operations is suspended")
78+    else {
79+        let payment = asPayment(i.payments[0])
80+        if ((0 >= payment.amount))
81+            then throw("Amount must be positive")
82+            else if ((1440 > period))
83+                then throw("24 hours is minimum vesting period")
84+                else {
85+                    let currentLockId = getIntegerValue(currentLockIdKey)
86+                    let callerAddressString = toBase58String(i.caller.bytes)
87+                    let paymentAssetIdString = if (!(isDefined(payment.assetId)))
88+                        then "WAVES"
89+                        else toBase58String(asByteVector(payment.assetId))
90+                    let key = ((callerAddressString + SEP) + toString(currentLockId))
91+                    let data = ((((((((toString(height) + SEP) + toString(payment.amount)) + SEP) + "0") + SEP) + toString(period)) + SEP) + paymentAssetIdString)
92+[StringEntry(key, data), IntegerEntry(currentLockIdKey, (currentLockId + 1))]
93+                    }
94+        }
95+
96+
97+
98+@Callable(i)
99+func withdraw (amount,lockId) = if (getBooleanValue(isFreezedKey))
100+    then throw("Contract operations is suspended")
101+    else if (if ((0 >= amount))
102+        then true
103+        else (0 > lockId))
104+        then throw("Amount must be positive or wrong lock id")
105+        else {
106+            let callerAddressString = toBase58String(i.caller.bytes)
107+            let key = ((callerAddressString + SEP) + toString(lockId))
108+            let dataArray = split(getStringValue(key), SEP)
109+            if ((size(dataArray) != 5))
110+                then throw("Internal error")
111+                else {
112+                    let storedHeight = dataArray[0]
113+                    let storedAmount = dataArray[1]
114+                    let storedTakedAmount = dataArray[2]
115+                    let storedVestingPeriod = dataArray[3]
116+                    let storedAssetId = dataArray[4]
117+                    let availableAmount = maxTakeableAmount(parseIntValue(storedHeight), parseIntValue(storedVestingPeriod), parseIntValue(storedAmount), parseIntValue(storedTakedAmount))
118+                    if ((amount > availableAmount))
119+                        then throw(("Requested amount is two big, max available amount is: " + toString(availableAmount)))
120+                        else {
121+                            let newData = ((((((((storedHeight + SEP) + storedAmount) + SEP) + toString((parseIntValue(storedTakedAmount) + amount))) + SEP) + storedVestingPeriod) + SEP) + storedAssetId)
122+                            let assetIdToTransfer = if ((storedAssetId == "WAVES"))
123+                                then unit
124+                                else fromBase58String(storedAssetId)
125+                            let amountToTreasury = treasuryAmount(amount)
126+                            let amountToUser = (amount - amountToTreasury)
127+                            let transactionResult = [StringEntry(key, newData), ScriptTransfer(i.caller, amountToUser, assetIdToTransfer)]
128+                            if ((amountToTreasury > 0))
129+                                then ScriptTransfer(i.caller, amountToTreasury, assetIdToTransfer) :: transactionResult
130+                                else transactionResult
131+                            }
132+                    }
133+            }
134+
135+
136+
137+@Callable(i)
138+func freezeContract (isUnfreeze) = {
139+    let adminAddress = getStringValue(adminContractKey)
140+    if ((adminAddress != toBase58String(i.caller.bytes)))
141+        then throw("Only admin contract can call this function")
142+        else [BooleanEntry(isFreezedKey, !(isUnfreeze))]
143+    }
144+
145+
146+
147+@Callable(i)
148+func changeFeeBasis (newFeeBasis) = {
149+    let adminAddress = getStringValue(adminContractKey)
150+    if ((adminAddress != toBase58String(i.caller.bytes)))
151+        then throw("Only admin contract can call this function")
152+        else if ((0 > newFeeBasis))
153+            then throw("Fee basis can't be negative")
154+            else if ((newFeeBasis > 1000))
155+                then throw("Fee basis can't be bigger than 10 percent")
156+                else [IntegerEntry(unlockFeeBasisKey, newFeeBasis)]
157+    }
158+
159+
160+@Verifier(tx)
161+func verify () = match tx {
162+    case _: MassTransferTransaction|TransferTransaction|SetScriptTransaction => 
163+        let verifiers = split(getStringValue(verifiersKey), SEP)
164+        let verifiersData = split(getStringValue(verifiersDataKey), SEP)
165+        let verifiersCount = parseIntValue(verifiersData[0])
166+        let verifiersRequired = parseIntValue(verifiersData[1])
167+        func sum (accum,next) =         {
168+            let validatedProofsCount = accum._1
169+            let currentProofsIndex = accum._2
170+            let isVerified = if (sigVerify(tx.bodyBytes, tx.proofs[currentProofsIndex], fromBase58String(next)))
171+                then 1
172+                else 0
173+            $Tuple2((validatedProofsCount + isVerified), (currentProofsIndex + 1))
174+            }
175+
176+        let validationData = {
177+            let $l = verifiers
178+            let $s = size($l)
179+            let $acc0 = $Tuple2(0, 0)
180+            func $f0_1 ($a,$i) =             if (($i >= $s))
181+                then $a
182+                else sum($a, $l[$i])
183+
184+            func $f0_2 ($a,$i) =             if (($i >= $s))
185+                then $a
186+                else throw("List size exceeds 8")
187+
188+            $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8)
189+            }
190+        (validationData._1 >= verifiersRequired)
191+    case _ => 
192+        sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
193+}
194+
github/deemru/w8io/169f3d6 
25.54 ms ◑