tx · 525AKwtCWfWFMyPPL2ecfnmjF6FXAYzXXHGDh1u7DJGB

3N3kKNoJohjVQYNLTrYTGTesr3nq3PZNh37:  -0.01000000 Waves

2024.03.18 17:58 [3023600] smart account 3N3kKNoJohjVQYNLTrYTGTesr3nq3PZNh37 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "525AKwtCWfWFMyPPL2ecfnmjF6FXAYzXXHGDh1u7DJGB",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1710773919755,
    "version": 2,
    "chainId": 84,
    "sender": "3N3kKNoJohjVQYNLTrYTGTesr3nq3PZNh37",
    "senderPublicKey": "vmMXxwQAMUAoisvL193ptPiTtaWQqL5YNu2zs1ouTbY",
    "proofs": [
        "2QFAFCFzYhsy8jJA7UnLbHUiyy5JvuJBGKsTibcVJDCeLpx5VKmo5SAvSaWgGAQxSSQzjMuiJ8YkoM5hjasM84yP"
    ],
    "script": "base64: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",
    "height": 3023600,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: 5zzWw2qQYEvxnqh3evKVySAUAWQj1kBBHrN9RfJ2k13b

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 7 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let separator = "__"
5+
6+let chainId = take(drop(this.bytes, 1), 1)
7+
8+let chainIdW = base58'2W'
9+
10+let contractFilename = "futures_calculator.ride"
11+
12+func wrapErr (s) = ((contractFilename + ": ") + s)
13+
14+
15+func throwErr (s) = throw(wrapErr(s))
16+
17+
18+let kFactoryAddress = "%s__factoryAddress"
19+
20+let factoryAddressOption = match getString(this, kFactoryAddress) {
21+    case s: String => 
22+        addressFromString(s)
23+    case _: Unit => 
24+        unit
25+    case _ => 
26+        throw("Match error")
27+}
28+
29+let factoryAddress = valueOrErrorMessage(factoryAddressOption, wrapErr("invalid factory address"))
30+
31+func mustAddress (i,address) = if ((i.caller == address))
32+    then true
33+    else throwErr("permission denied")
34+
35+
36+func mustThis (i) = mustAddress(i, this)
37+
38+
39+func mustFactory (i) = mustAddress(i, factoryAddress)
40+
41+
42+let wavesString = "WAVES"
43+
44+let queueItemSize = 32
45+
46+func parseAssetId (input) = if ((input == wavesString))
47+    then unit
48+    else fromBase58String(input)
49+
50+
51+func assetIdToString (input) = if ((input == unit))
52+    then wavesString
53+    else toBase58String(value(input))
54+
55+
56+let kAccountScript = "%s__accountScript"
57+
58+func accountScript () = valueOrErrorMessage(getBinary(factoryAddress, kAccountScript), wrapErr("account script is not set"))
59+
60+
61+let kRewardAmount = "%s__rewardAmount"
62+
63+func rewardAmount () = valueOrErrorMessage(getInteger(factoryAddress, kRewardAmount), wrapErr("reward amount is not set"))
64+
65+
66+let kAccountsLimit = "%s__accountsLimit"
67+
68+let accountsLimitDefault = 20
69+
70+func accountsLimit () = valueOrElse(getInteger(factoryAddress, kAccountsLimit), accountsLimitDefault)
71+
72+
73+let REQUEST_STATUS_EMPTY = 0
74+
75+let REQUEST_STATUS_READY = 1
76+
77+func kRequestStatus (requestId) = makeString(["%s%s", toBase58String(requestId), "status"], separator)
78+
79+
80+func kAccountCreatorPublicKey (accountAddress) = makeString(["%s%s", toString(accountAddress), "creatorPublicKey"], separator)
81+
82+
83+func kRequestOwnerPublicKey (requestId) = makeString(["%s%s", toBase58String(requestId), "ownerPublicKey"], separator)
84+
85+
86+func kRequestAmountAssetId (requestId) = makeString(["%s%s", toBase58String(requestId), "amountAssetId"], separator)
87+
88+
89+func kRequestPriceAssetId (requestId) = makeString(["%s%s", toBase58String(requestId), "priceAssetId"], separator)
90+
91+
92+func kRequestIdToAccountPublicKey (requestId) = makeString(["%s%s", toBase58String(requestId), "requestIdToAccountPublicKey"], separator)
93+
94+
95+func kAccountAddressToRequestId (accountAddress) = makeString(["%s%s", toString(accountAddress), "accountAddressToRequestId"], separator)
96+
97+
98+func kRequestsQueue () = makeString(["%s", "requestsQueue"], separator)
99+
100+
101+func requestsQueue () = valueOrElse(getBinary(factoryAddress, kRequestsQueue()), base58'')
102+
103+
104+func kAccountsQueue () = makeString(["%s", "accountsQueue"], separator)
105+
106+
107+func accountsQueue () = valueOrElse(getBinary(factoryAddress, kAccountsQueue()), base58'')
108+
109+
110+func kRequestsByOwner (ownerAddress) = makeString(["%s%s", "accounts", toString(ownerAddress)], separator)
111+
112+
113+func requestsByOwner (ownerAddress) = valueOrElse(getBinary(factoryAddress, kRequestsByOwner(ownerAddress)), base58'')
114+
115+
116+func kPairAllowed (amountAssetId,priceAssetId) = makeString(["%s%s%s", assetIdToString(amountAssetId), assetIdToString(priceAssetId), "pairAllowed"], separator)
117+
118+
119+func pairAllowed (amountAssetId,priceAssetId) = valueOrElse(getBoolean(factoryAddress, kPairAllowed(amountAssetId, priceAssetId)), false)
120+
121+
122+@Callable(i)
123+func init (factoryAddressStr) = {
124+    let checkCaller = mustThis(i)
125+    if ((checkCaller == checkCaller))
126+        then $Tuple2([StringEntry(kFactoryAddress, factoryAddressStr)], unit)
127+        else throw("Strict value is not equal to itself.")
128+    }
129+
130+
131+
132+@Callable(i)
133+func requestAccount (callerPublicKey,args) = {
134+    let checkCaller = mustFactory(i)
135+    if ((checkCaller == checkCaller))
136+        then {
137+            let amountAssetIdStr = args[0]
138+            let priceAssetIdStr = args[1]
139+            let userAddress = addressFromPublicKey(callerPublicKey)
140+            let requestId = sha256(((userAddress.bytes + fromBase58String(amountAssetIdStr)) + fromBase58String(priceAssetIdStr)))
141+            let amountAssetId = parseAssetId(amountAssetIdStr)
142+            let priceAssetId = parseAssetId(priceAssetIdStr)
143+            let userRequestsNumber = (size(kRequestsByOwner(userAddress)) / queueItemSize)
144+            let checks = [if ((size(i.payments) == 1))
145+                then true
146+                else throwErr("1 payment is required"), if ((i.payments[0].assetId == unit))
147+                then true
148+                else throwErr("invalid asset"), if ((i.payments[0].amount == rewardAmount()))
149+                then true
150+                else throwErr("invalid amount"), if (pairAllowed(amountAssetId, priceAssetId))
151+                then true
152+                else throwErr("pair is not allowed"), if ((getInteger(factoryAddress, kRequestStatus(requestId)) == unit))
153+                then true
154+                else throwErr("account is already exists"), if ((accountsLimit() > userRequestsNumber))
155+                then true
156+                else throwErr(("accounts limit is " + toString(accountsLimit())))]
157+            if ((checks == checks))
158+                then {
159+                    let $t050206376 = if ((size(accountsQueue()) == 0))
160+                        then $Tuple2([ScriptTransfer(factoryAddress, rewardAmount(), unit)], [invoke(factoryAddress, "integerEntry", [kRequestStatus(requestId), REQUEST_STATUS_EMPTY], nil), invoke(factoryAddress, "binaryEntry", [kRequestsQueue(), (requestsQueue() + requestId)], nil)])
161+                        else {
162+                            let accountPublicKey = take(accountsQueue(), queueItemSize)
163+                            let accountAddress = addressFromPublicKey(accountPublicKey)
164+                            let creatorAddress = addressFromPublicKey(valueOrErrorMessage(getBinary(factoryAddress, kAccountCreatorPublicKey(accountAddress)), wrapErr("invalid creator public key")))
165+                            $Tuple2([ScriptTransfer(creatorAddress, rewardAmount(), unit)], [invoke(factoryAddress, "binaryEntry", [kAccountsQueue(), drop(accountsQueue(), queueItemSize)], nil), invoke(factoryAddress, "integerEntry", [kRequestStatus(requestId), REQUEST_STATUS_READY], nil), invoke(factoryAddress, "binaryEntry", [kRequestIdToAccountPublicKey(requestId), accountPublicKey], nil), invoke(factoryAddress, "stringEntry", [kAccountAddressToRequestId(accountAddress), toBase58String(requestId)], nil)])
166+                            }
167+                    let actions = $t050206376._1
168+                    let factoryActions = $t050206376._2
169+                    $Tuple2(actions, (factoryActions ++ [invoke(factoryAddress, "binaryEntry", [kRequestOwnerPublicKey(requestId), callerPublicKey], nil), invoke(factoryAddress, "binaryEntry", [kRequestsByOwner(userAddress), (requestsByOwner(userAddress) + requestId)], nil), invoke(factoryAddress, "stringEntry", [kRequestAmountAssetId(requestId), amountAssetIdStr], nil), invoke(factoryAddress, "stringEntry", [kRequestPriceAssetId(requestId), priceAssetIdStr], nil)]))
170+                    }
171+                else throw("Strict value is not equal to itself.")
172+            }
173+        else throw("Strict value is not equal to itself.")
174+    }
175+
176+
177+
178+@Callable(i)
179+func addAccount (callerPublicKey,args) = {
180+    let checkCaller = mustFactory(i)
181+    if ((checkCaller == checkCaller))
182+        then {
183+            let creatorPublicKey = fromBase58String(args[0])
184+            let accountPublicKey = callerPublicKey
185+            let accountAddress = addressFromPublicKey(callerPublicKey)
186+            let creatorAddress = addressFromPublicKey(creatorPublicKey)
187+            let checks = [if ((getBinary(factoryAddress, kAccountCreatorPublicKey(accountAddress)) == unit))
188+                then true
189+                else throwErr("account is already exists"), if (            match scriptHash(accountAddress) {
190+                case b: ByteVector => 
191+                    (b == blake2b256_32Kb(accountScript()))
192+                case _ => 
193+                    false
194+            })
195+                then true
196+                else throwErr("invalid script")]
197+            if ((checks == checks))
198+                then {
199+                    let $t075778579 = if ((size(requestsQueue()) == 0))
200+                        then $Tuple2(nil, [invoke(factoryAddress, "binaryEntry", [kAccountsQueue(), (accountsQueue() + accountPublicKey)], nil)])
201+                        else {
202+                            let requestId = take(requestsQueue(), queueItemSize)
203+                            $Tuple2(nil, [invoke(factoryAddress, "integerEntry", [kRequestStatus(requestId), REQUEST_STATUS_READY], nil), invoke(factoryAddress, "binaryEntry", [kRequestIdToAccountPublicKey(requestId), accountPublicKey], nil), invoke(factoryAddress, "binaryEntry", [kRequestsQueue(), drop(requestsQueue(), queueItemSize)], nil), invoke(factoryAddress, "stringEntry", [kAccountAddressToRequestId(accountAddress), toBase58String(requestId)], nil), invoke(factoryAddress, "transferWaves", [creatorAddress.bytes, rewardAmount()], nil)])
204+                            }
205+                    let actions = $t075778579._1
206+                    let factoryActions = $t075778579._2
207+                    $Tuple2(actions, (factoryActions ++ [invoke(factoryAddress, "binaryEntry", [kAccountCreatorPublicKey(accountAddress), creatorPublicKey], nil)]))
208+                    }
209+                else throw("Strict value is not equal to itself.")
210+            }
211+        else throw("Strict value is not equal to itself.")
212+    }
213+
214+
215+
216+@Callable(i)
217+func deposit (callerPublicKey,args) = {
218+    let checkCaller = mustFactory(i)
219+    if ((checkCaller == checkCaller))
220+        then {
221+            let accountAddress = valueOrErrorMessage(addressFromString(args[0]), wrapErr("invalid account address"))
222+            let payment = i.payments[0]
223+            let actions = [ScriptTransfer(accountAddress, payment.amount, payment.assetId)]
224+            let factoryActions = nil
225+            $Tuple2(actions, factoryActions)
226+            }
227+        else throw("Strict value is not equal to itself.")
228+    }
229+
230+
231+
232+@Callable(i)
233+func withdraw (callerPublicKey,args) = {
234+    let checkCaller = mustFactory(i)
235+    if ((checkCaller == checkCaller))
236+        then {
237+            let userAddress = addressFromPublicKey(callerPublicKey)
238+            let accountAddress = valueOrErrorMessage(addressFromString(args[0]), wrapErr("invalid account address"))
239+            let amount = valueOrErrorMessage(parseInt(args[1]), wrapErr("invalid amount"))
240+            let assetId = parseAssetId(args[2])
241+            let invocations = [invoke(accountAddress, "transferAsset", [userAddress.bytes, amount, assetId], nil)]
242+            $Tuple2(nil, invocations)
243+            }
244+        else throw("Strict value is not equal to itself.")
245+    }
246+
247+
github/deemru/w8io/873ac7e 
20.25 ms ◑