tx · EfadDsnSUbQ3SmQMRjFtQF4YgLXVbJRtes1sVbapVUg5

3Mpnku3oancBEqtQt4Hj2JBfPnERrSexrt6:  -0.01000000 Waves

2023.09.06 17:14 [2743620] smart account 3Mpnku3oancBEqtQt4Hj2JBfPnERrSexrt6 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "EfadDsnSUbQ3SmQMRjFtQF4YgLXVbJRtes1sVbapVUg5",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1694009792223,
    "version": 2,
    "chainId": 84,
    "sender": "3Mpnku3oancBEqtQt4Hj2JBfPnERrSexrt6",
    "senderPublicKey": "CRyEtaZUy7FWVzzASpq48CRzFmjoDh9TnTiMiE2XJYJ6",
    "proofs": [
        "52u1FRjeDZr3m3iC7NbvLJiGrQqjJY1p1aKhm7v9HUTBbGH2CW8ttV4oATvHcfeCG4yictEj336BU8HzyTaKfuA1"
    ],
    "script": "base64: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",
    "height": 2743620,
    "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(getBoolean(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 
28.55 ms ◑