tx · 474oN8QunrKjBMXHuqT3Bk17FZqdqKoTL525TxF2dQH3

3MwXxvhU6zXDcodoRnehqGnQodoAu7Sj7aL:  -0.01000000 Waves

2023.09.06 17:01 [2743606] smart account 3MwXxvhU6zXDcodoRnehqGnQodoAu7Sj7aL > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "474oN8QunrKjBMXHuqT3Bk17FZqdqKoTL525TxF2dQH3",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1694008933048,
    "version": 2,
    "chainId": 84,
    "sender": "3MwXxvhU6zXDcodoRnehqGnQodoAu7Sj7aL",
    "senderPublicKey": "9q2vLP5Wjb39hCnH7qXVPRQ9oSWVnfP7k5u5SC8jfqYz",
    "proofs": [
        "315ZSKK3CKJH2vzwBDBLh5hsffTcBTb8gydGBCLBhy3HWpYWFWD8dBRdntXbG98UQKFzyYLGed9dxqy8u2fVn7qG"
    ],
    "script": "base64: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",
    "height": 2743606,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

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