tx · B4K4TgP3v5SDc9pU9DHwDhFMTFGT7UR3w2byA7KVvZc6

3Mu2qb3Z3JfzpTYEUkcMtTEGdS96PzDqBa4:  -0.01000000 Waves

2020.05.29 19:45 [1020007] smart account 3Mu2qb3Z3JfzpTYEUkcMtTEGdS96PzDqBa4 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "B4K4TgP3v5SDc9pU9DHwDhFMTFGT7UR3w2byA7KVvZc6",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1590770738638,
    "version": 1,
    "sender": "3Mu2qb3Z3JfzpTYEUkcMtTEGdS96PzDqBa4",
    "senderPublicKey": "6eLgWWPsXjdnRTDQ7rs2V2jngePeDyCGQyZUHF6YtqzJ",
    "proofs": [
        "47bWxqj3CsPfCa6xLYqcsPNTKACS8fQncTpoxe1poYhxrFQ8tDZSEobFRmNxebtkKECLYLSHX9QcKfkWFnwj81kN"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 1020007,
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 3 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let DSBA = "DSBA Address"
5+
6+let USDN = base58'DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p'
7+
8+let REVIEW = "review"
9+
10+let APPROVED = "approved"
11+
12+let REJECTED = "rejected"
13+
14+let FUNDED = "funded"
15+
16+let NONE = "none"
17+
18+func getNumberByKey (key) = {
19+    let num =     match getInteger(this, key) {
20+        case a: Int => 
21+            a
22+        case _ => 
23+            0
24+    }
25+    num
26+    }
27+
28+
29+func getStrByKey (key) = {
30+    let str =     match getString(this, key) {
31+        case a: String => 
32+            a
33+        case _ => 
34+            NONE
35+    }
36+    str
37+    }
38+
39+
40+func getKeyTokenOwner (tokenId) = (("token_" + tokenId) + "_owner")
41+
42+
43+func getValueTokenOwner (tokenId) = getStrByKey(getKeyTokenOwner(tokenId))
44+
45+
46+func getKeyTokenPrice (tokenId) = (("token_" + tokenId) + "_price")
47+
48+
49+func getValueTokenPrice (tokenId) = getNumberByKey(getKeyTokenPrice(tokenId))
50+
51+
52+func getKeyTokenStatus (tokenId) = (("token_" + tokenId) + "_status")
53+
54+
55+func getValueTokenStatus (tokenId) = getStrByKey(getKeyTokenStatus(tokenId))
56+
57+
58+func getKeyAccountBalance (account) = (("account_" + account) + "_balance")
59+
60+
61+func getValueAccountBalance (account) = getNumberByKey(getKeyAccountBalance(account))
62+
63+
64+func getKeyAccountTokenBalance (account,tokenId) = (((("account_" + account) + "_token_") + tokenId) + "_balance")
65+
66+
67+func getValueAccountTokenBalance (account,tokenId) = getNumberByKey(getKeyAccountTokenBalance(account, tokenId))
68+
69+
70+func getExtAdressOracle () = extract(addressFromString("dsba-funds address here"))
71+
72+
73+func getExtKeyFund (fundAddress) = ("fund_" + fundAddress)
74+
75+
76+func checkFund (account) = {
77+    let bool =     match getBoolean(getExtAdressOracle(), getExtKeyFund(account)) {
78+        case b: Boolean => 
79+            b
80+        case _ => 
81+            false
82+    }
83+    bool
84+    }
85+
86+
87+@Callable(i)
88+func apply (tokenPrice) = {
89+    let tokenOwner = toBase58String(i.caller.bytes)
90+    let pmt = extract(i.payment)
91+    let tokenId = toBase58String(extract(pmt.assetId))
92+    if (if (!(isDefined(pmt.assetId)))
93+        then true
94+        else (pmt.assetId == USDN))
95+        then throw("can't use WAVES or USDN")
96+        else if ((getValueTokenOwner(tokenId) != NONE))
97+            then throw("this token already exist")
98+            else if (checkFund(tokenOwner))
99+                then throw("funds can't apply")
100+                else if ((0 >= tokenPrice))
101+                    then throw("token price must be positive")
102+                    else WriteSet([DataEntry(getKeyTokenOwner(tokenId), tokenOwner), DataEntry(getKeyTokenPrice(tokenId), tokenPrice), DataEntry(getKeyAccountTokenBalance(tokenOwner, tokenId), pmt.amount), DataEntry(getKeyTokenStatus(tokenId), REVIEW)])
103+    }
104+
105+
106+
107+@Callable(i)
108+func setTokenStatus (tokenId,status) = {
109+    let caller = toBase58String(i.caller.bytes)
110+    if ((getValueTokenOwner(tokenId) == NONE))
111+        then throw("this token doesn't exist")
112+        else if ((caller != DSBA))
113+            then throw("only DSBA can call this function")
114+            else if (if ((status != APPROVED))
115+                then (status != REJECTED)
116+                else false)
117+                then throw("invalid status")
118+                else WriteSet([DataEntry(getKeyTokenStatus(tokenId), status)])
119+    }
120+
121+
122+
123+@Callable(i)
124+func invest (tokenId,tokenQuantity) = {
125+    let fund = toBase58String(i.caller.bytes)
126+    let pmt = extract(i.payment)
127+    let tokenOwner = getValueTokenOwner(tokenId)
128+    let availableTokenQuantity = getValueAccountTokenBalance(tokenOwner, tokenId)
129+    if ((pmt.assetId != USDN))
130+        then throw("can use WAVES only at the moment")
131+        else if ((tokenOwner == NONE))
132+            then throw("this token doesn't exist")
133+            else if (!(checkFund(fund)))
134+                then throw("only listed funds can invest")
135+                else if ((getValueTokenStatus(tokenId) == FUNDED))
136+                    then throw("all tokens has been sold")
137+                    else if ((getValueTokenStatus(tokenId) != APPROVED))
138+                        then throw("this token is not approved")
139+                        else if ((0 >= tokenQuantity))
140+                            then throw("tokenQuantity must be positive")
141+                            else if ((tokenQuantity > availableTokenQuantity))
142+                                then throw("such quantity of tokens is not available")
143+                                else if (((tokenQuantity * getValueTokenPrice(tokenId)) != pmt.amount))
144+                                    then throw("quantity of tokens doesn't match payment amount")
145+                                    else if ((availableTokenQuantity == tokenQuantity))
146+                                        then WriteSet([DataEntry(getKeyAccountTokenBalance(fund, tokenId), (getValueAccountTokenBalance(fund, tokenId) + tokenQuantity)), DataEntry(getKeyAccountTokenBalance(tokenOwner, tokenId), (availableTokenQuantity - tokenQuantity)), DataEntry(getKeyAccountBalance(tokenOwner), (getValueAccountBalance(tokenOwner) + pmt.amount)), DataEntry(getKeyTokenStatus(tokenId), FUNDED)])
147+                                        else WriteSet([DataEntry(getKeyAccountTokenBalance(fund, tokenId), (getValueAccountTokenBalance(fund, tokenId) + tokenQuantity)), DataEntry(getKeyAccountTokenBalance(tokenOwner, tokenId), (availableTokenQuantity - tokenQuantity)), DataEntry(getKeyAccountBalance(tokenOwner), (getValueAccountBalance(tokenOwner) + pmt.amount))])
148+    }
149+
150+
151+
152+@Callable(i)
153+func revokeInvestment (tokenId,tokenQuantity) = {
154+    let fund = toBase58String(i.caller.bytes)
155+    let tokenOwner = getValueTokenOwner(tokenId)
156+    let currentTokenBalance = getValueAccountTokenBalance(fund, tokenId)
157+    if ((tokenOwner == NONE))
158+        then throw("this token doesn't exist")
159+        else if (!(checkFund(fund)))
160+            then throw("only listed funds can revoke investments")
161+            else if ((getValueTokenStatus(tokenId) != APPROVED))
162+                then throw("this token is not approved")
163+                else if ((0 >= tokenQuantity))
164+                    then throw("tokenQuantity must be positive")
165+                    else if ((tokenQuantity > currentTokenBalance))
166+                        then throw("you don't have such quantity of tokens")
167+                        else if (((tokenQuantity * getValueTokenPrice(tokenId)) > getValueAccountBalance(tokenOwner)))
168+                            then throw("quantity of tokens doesn't match payment amount")
169+                            else WriteSet([DataEntry(getKeyAccountTokenBalance(fund, tokenId), (currentTokenBalance - tokenQuantity)), DataEntry(getKeyAccountTokenBalance(tokenOwner, tokenId), (getValueAccountTokenBalance(tokenOwner, tokenId) + tokenQuantity)), DataEntry(getKeyAccountBalance(tokenOwner), (getValueAccountBalance(tokenOwner) - (tokenQuantity * getValueTokenPrice(tokenId)))), DataEntry(getKeyAccountBalance(fund), (getValueAccountBalance(fund) + (tokenQuantity * getValueTokenPrice(tokenId))))])
170+    }
171+
172+
173+
174+@Callable(i)
175+func withdraw () = {
176+    let fund = toBase58String(i.caller.bytes)
177+    let currentBalance = getValueAccountBalance(fund)
178+    if (!(checkFund(fund)))
179+        then throw("only listed funds can withdraw")
180+        else if ((0 >= currentBalance))
181+            then throw("balance must be positive")
182+            else ScriptResult(WriteSet([DataEntry(getKeyAccountBalance(fund), 0)]), TransferSet([ScriptTransfer(addressFromStringValue(fund), currentBalance, USDN)]))
183+    }
184+
185+
186+
187+@Callable(i)
188+func withdrawTokens (tokenId) = {
189+    let fund = toBase58String(i.caller.bytes)
190+    let currentTokenBalance = getValueAccountTokenBalance(fund, tokenId)
191+    if (!(checkFund(fund)))
192+        then throw("only listed funds can withdraw tokens")
193+        else if ((0 >= currentTokenBalance))
194+            then throw("token balance must be positive")
195+            else ScriptResult(WriteSet([DataEntry(getKeyAccountTokenBalance(fund, tokenId), 0)]), TransferSet([ScriptTransfer(i.caller, currentTokenBalance, toBytes(tokenId))]))
196+    }
197+
198+
199+
200+@Callable(i)
201+func withdrawFunding (tokenId) = {
202+    let tokenOwner = toBase58String(i.caller.bytes)
203+    let amount = getValueAccountBalance(tokenOwner)
204+    if ((tokenOwner != getValueTokenOwner(tokenId)))
205+        then throw("you are not token owner")
206+        else if ((getValueTokenStatus(tokenId) != FUNDED))
207+            then throw("fundrising is not ended")
208+            else if ((0 >= amount))
209+                then throw("amount must be positive")
210+                else ScriptResult(WriteSet([DataEntry(getKeyAccountBalance(tokenOwner), 0)]), TransferSet([ScriptTransfer(i.caller, amount, USDN)]))
211+    }
212+
213+
214+@Verifier(tx)
215+func verify () = match tx {
216+    case _ => 
217+        false
218+}
219+
github/deemru/w8io/3ef1775 
42.63 ms ◑