tx · CdbCYxmNV28TzyPCjFTv7DxdhA1frANgFsVqtj4raUMj

3N31yX7N3xk5GJhcMjtKRGpFkBNfkc6KK3j:  -0.01000000 Waves

2020.09.22 19:28 [1188749] smart account 3N31yX7N3xk5GJhcMjtKRGpFkBNfkc6KK3j > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "CdbCYxmNV28TzyPCjFTv7DxdhA1frANgFsVqtj4raUMj",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1600792216248,
    "version": 1,
    "sender": "3N31yX7N3xk5GJhcMjtKRGpFkBNfkc6KK3j",
    "senderPublicKey": "BCuUe9A1b1EY38ghAwYPZX6RwcJqBdrdRD9z1QwKjBxp",
    "proofs": [
        "4DWFWmHiBDEFYDjJNiu6sB4rctnkNCwL6C7h2nP4WxSqV892FNMdXzqQ5VohjGwAPc39ZEWPHYpF6w268H9n2qX5"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 1188749,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 4 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+func a () = "%s__accumulatedFee"
5+
6+
7+func b () = "%s__ucollateral"
8+
9+
10+func c () = "%s__totalLendedAtOtherAccs"
11+
12+
13+func d (e) = ("%s%s__assetLockedTotal__" + e)
14+
15+
16+func f (g,h,i) = ((((("%s%s%d%s__defoAssetOperation__" + h) + "__") + toString(g)) + "__") + i)
17+
18+
19+func j () = "%s__factory"
20+
21+
22+func k (l) = ("%s%s__lendedBaseAssetAmount__" + l)
23+
24+
25+func m (l) = ("%s%s__price__" + l)
26+
27+
28+let n = 1
29+
30+let o = 2
31+
32+let p = 3
33+
34+let q = 4
35+
36+let r = 5
37+
38+func s (t,u,v,w,x,y,z) = ((((((((((((("%d%s%d%s%d%d%d__" + toString(t)) + "__") + u) + "__") + toString(w)) + "__") + x) + "__") + toString(v)) + "__") + toString(y)) + "__") + toString(z))
39+
40+
41+func A (B,C,D,E,F) = ((((((((((((("%s%s%d%s%d%d%d__" + B) + "__") + toBase58String(value(C.assetId))) + "__") + toString(C.amount)) + "__") + toBase58String(value(D.assetId))) + "__") + toString(D.amount)) + "__") + toString(E)) + "__") + toString(F))
42+
43+
44+func G (H) = {
45+    let I = valueOrErrorMessage(getString(this, H), ("There is no request for passed arguments: " + H))
46+    split(I, "__")
47+    }
48+
49+
50+let J = -1
51+
52+let K = "NULL"
53+
54+let L = addressFromStringValue(valueOrErrorMessage(getString(this, j()), ((("No config at this=" + toString(this)) + " for key=") + j())))
55+
56+func M () = "%s%s__commonConfig__debtAssetId"
57+
58+
59+func N (O) = (("%s%s%s__defoAsset__" + O) + "__config")
60+
61+
62+func P (Q) = (("%s%s%s__defoAsset__" + toString(Q)) + "__currentPool")
63+
64+
65+func R (l) = (("%s%s%s__defoAsset__" + l) + "__addressByAssetCode")
66+
67+
68+func S () = valueOrErrorMessage(getString(L, M()), ((("No config at factory=" + toString(L)) + " for key=") + M()))
69+
70+
71+func T (O) = split(valueOrErrorMessage(getString(L, N(O)), ((("No config at factory=" + toString(L)) + " for key=") + N(O))), "__")
72+
73+
74+func U (l) = {
75+    let O = valueOrErrorMessage(getString(L, R(l)), ((("No config at factory=" + toString(L)) + " for key=") + R(l)))
76+    $Tuple2(O, T(O))
77+    }
78+
79+
80+let V = 1
81+
82+let W = 2
83+
84+let X = 3
85+
86+let Y = 4
87+
88+let Z = 5
89+
90+let aa = 6
91+
92+let ab = 7
93+
94+let ac = 8
95+
96+let ad = 9
97+
98+let ae = 10
99+
100+let af = 11
101+
102+let ag = 12
103+
104+let ah = 13
105+
106+let ai = 14
107+
108+let aj = T(toString(this))
109+
110+let ak = aj[V]
111+
112+let al = fromBase58String(aj[W])
113+
114+let am = addressFromStringValue(aj[ac])
115+
116+let an = parseIntValue(aj[aa])
117+
118+let ao = aj[Z]
119+
120+let ap = fromBase58String(ao)
121+
122+let aq = parseIntValue(aj[Y])
123+
124+let ar = parseIntValue(aj[ad])
125+
126+let as = parseIntValue(aj[ae])
127+
128+let at = parseIntValue(aj[af])
129+
130+let au = parseIntValue(aj[ag])
131+
132+let av = parseIntValue(aj[ah])
133+
134+let aw = parseIntValue(aj[ai])
135+
136+func ax (l) = valueOrErrorMessage(getInteger(am, m(l)), ((("No price at priceOracle=" + toString(am)) + " for key=") + m(l)))
137+
138+
139+func ay () = valueOrErrorMessage(getInteger(am, "currIdx"), ("No currIdx at controlAcc=" + toString(am)))
140+
141+
142+func az (aA) = {
143+    let aB = ("idxHeight_" + toString(aA))
144+    valueOrElse(getInteger(am, aB), 0)
145+    }
146+
147+
148+func aC (aD) = {
149+    let aE = ("price_" + toString(aD))
150+    valueOrErrorMessage(getInteger(am, aE), ((("No " + aE) + " at controlAcc=") + toString(am)))
151+    }
152+
153+
154+func aF () = valueOrElse(getInteger(this, ((("rpd_balance_" + ao) + "_") + toString(this))), 0)
155+
156+
157+let aG = valueOrElse(getInteger(this, b()), 0)
158+
159+let aH = valueOrElse(getInteger(this, a()), 0)
160+
161+let aI = getIntegerValue(L, P(this))
162+
163+let aJ = (assetBalance(this, ap) + aF())
164+
165+let aK = if ((0 > aG))
166+    then 0
167+    else aG
168+
169+let aL = (aJ - aG)
170+
171+let v = ax(aj[V])
172+
173+let aM = (((aq + an) * v) / aq)
174+
175+let aN = value(assetInfo(al)).quantity
176+
177+let aO = valueOrElse(getInteger(this, d(ao)), 0)
178+
179+let aP = (aI - aO)
180+
181+func aQ (aR,aS,aT,aU,aV,aW) = {
182+    let aX = (fraction(aP, aq, aM) - aN)
183+    let aY = fraction(aS, aq, aV)
184+    let aZ = if ((aY > aX))
185+        then aX
186+        else aY
187+    let ba = fraction((aq - aW), aZ, aq)
188+    let z = (aZ - ba)
189+    let bb = fraction(aZ, aV, aq)
190+    let bc = (aS - bb)
191+    if ((0 >= aX))
192+        then throw((("impossible to issue new " + ak) + ": not enough collateral"))
193+        else if ((aU > aS))
194+            then throw(((((("impossible to issue new " + ak) + ": payment=") + toString(aS)) + "is less then min amount=") + toString(aU)))
195+            else $Tuple2([IntegerEntry(b(), (aG + bb)), StringEntry(f(height, toString(aR), "FINISHED"), s(aS, toBase58String(aT), v, ba, toBase58String(al), aZ, z)), Reissue(al, (ba + z), true), ScriptTransfer(aR, ba, al), ScriptTransfer(aR, bc, aT), IntegerEntry(a(), (aH + z))], bc)
196+    }
197+
198+
199+@Callable(bd)
200+func buyAsset () = {
201+    let be = value(bd.payments[0])
202+    let bf = value(be.assetId)
203+    if ((bf != ap))
204+        then throw(((("Payment asset id doesn't match basic asset: expected=" + toBase58String(ap)) + " actual=") + toBase58String(bf)))
205+        else aQ(bd.caller, be.amount, bf, ar, v, av)._1
206+    }
207+
208+
209+
210+@Callable(bd)
211+func sellAsset () = {
212+    let be = value(bd.payments[0])
213+    let bg = value(be.assetId)
214+    let bh = toString(bd.caller)
215+    if ((bg != al))
216+        then throw(((("Invalid payment asset id: expected=" + toBase58String(al)) + " actual=") + toBase58String(bg)))
217+        else if ((as > be.amount))
218+            then throw(((("Payment amount less then mininimal allowed: paymentAmount=" + toString(be.amount)) + " minAmount=") + toString(as)))
219+            else {
220+                let bi = be.amount
221+                let bj = fraction((aq - aw), bi, aq)
222+                let bk = (bi - bj)
223+                let bl = fraction(bk, v, aq)
224+                let bm = if ((bl > aL))
225+                    then aL
226+                    else bl
227+                let bn = fraction(bm, aq, v)
228+                let bc = (bk - bn)
229+[IntegerEntry(b(), (aG - bm)), StringEntry(f(height, bh, "FINISHED"), s(be.amount, toBase58String(bg), v, bm, ao, bi, bj)), Burn(al, bn), ScriptTransfer(bd.caller, bm, ap), ScriptTransfer(bd.caller, bc, al), IntegerEntry(a(), (aH + bj))]
230+                }
231+    }
232+
233+
234+
235+@Callable(bd)
236+func crossExchange (bo,bp,bq) = {
237+    let be = value(bd.payments[0])
238+    let bg = value(be.assetId)
239+    let br = toBase58String(bg)
240+    let bs = be.amount
241+    let bh = toString(bd.caller)
242+    let bt = aj
243+    let bu = U(bq)
244+    let bv = bu._2
245+    let bw = valueOrErrorMessage(addressFromString(bu._1), ("couldn't parse address from string for assetCode=" + bq))
246+    let bx = valueOrErrorMessage(parseInt(bv[ae]), ("minSellPmt parsing error: rawVal=" + bv[ae]))
247+    if ((aj[W] != bo))
248+        then throw(((("buyAsset confirmation failed: buyAssetIdConfirm=" + aj[W]) + " BUT buyAssetId=") + bo))
249+        else if ((bv[W] != br))
250+            then throw(((("sellAsset confirmation failed: sellAssetIdConfirm=" + bv[W]) + "BUT pmtAsset=") + br))
251+            else if ((aj[X] != "ISSUED"))
252+                then throw(((("toAsset has not been issued yet: buyAssetId=" + bo) + " BUT status=") + aj[X]))
253+                else if ((bv[X] != "ISSUED"))
254+                    then throw(((("fromAssetCfg has not been issued yet: sellAssetId=" + br) + " BUT status=") + bv[X]))
255+                    else {
256+                        let by = v
257+                        let bz = ax(bq)
258+                        let aV = fraction(by, aq, bz)
259+                        let bA = fromBase58String(S())
260+                        let bB = fraction(bz, bs, aq)
261+                        let bC = valueOrElse(getInteger(this, c()), 0)
262+                        let bD = k(bq)
263+                        let bE = valueOrElse(getInteger(this, bD), 0)
264+                        let bF = aQ(bd.caller, bs, bg, bx, aV, fraction(av, 150, 100))
265+                        ((bF._1 :+ IntegerEntry(bD, (bE + bB))) :+ IntegerEntry(c(), (bC + bB)))
266+                        }
267+    }
268+
269+
270+
271+@Callable(bd)
272+func rebalanceDebts () = {
273+    let bA = fromBase58String(S())
274+    let bG = value(bd.payments[0])
275+    let bH = value(bG.assetId)
276+    let bI = value(bd.payments[1])
277+    let bJ = value(bI.assetId)
278+    let bK = toString(bd.caller)
279+    let bL = T(bK)
280+    let B = bL[V]
281+    let bD = k(B)
282+    let bM = valueOrErrorMessage(getInteger(this, bD), ("No debts for " + B))
283+    if ((bA != bH))
284+        then throw(((("invalid debt asset id in the first paymet: expected=" + toBase58String(bA)) + " actual=") + toBase58String(bH)))
285+        else if ((ap != bJ))
286+            then throw(((("invalid base asset id in the second payment: expected=" + toBase58String(ap)) + " actual=") + toBase58String(bJ)))
287+            else if ((bG.amount != bI.amount))
288+                then throw("first payment amount doesn't match to the second payment amount")
289+                else if ((0 >= bM))
290+                    then throw(("lendedAmt is less then zero: lendedAmt=" + toString(bM)))
291+                    else if ((0 >= bG.amount))
292+                        then throw(("attached payment must be greater then 0: pmt0.amount=" + toString(bG.amount)))
293+                        else if ((bG.amount > bM))
294+                            then throw(((("attached payment is grater than required: pmtAmount=" + toString(bG.amount)) + " lendedAmt=") + toString(bM)))
295+                            else {
296+                                let bC = valueOrElse(getInteger(this, c()), 0)
297+                                let F = (bM - bG.amount)
298+[IntegerEntry(bD, F), IntegerEntry(c(), (bC - bG.amount)), StringEntry(("%s%s__rebalanceTrace__" + toBase58String(bd.transactionId)), A(B, bG, bI, bM, F))]
299+                                }
300+    }
301+
302+
303+
304+@Callable(bd)
305+func withdraw (bN,g,aA) = {
306+    let H = f(g, bN, "PENDING")
307+    let bO = G(H)
308+    let t = parseIntValue(bO[n])
309+    let u = bO[o]
310+    let x = bO[r]
311+    if ((g > height))
312+        then throw((("Please wait " + toString(g)) + " to withdraw your funds"))
313+        else {
314+            let bP = t
315+            if ((0 >= bP))
316+                then throw("LockedAmount <= 0")
317+                else {
318+                    let bQ = d(bO[o])
319+                    let bR = valueOrErrorMessage(getInteger(this, bQ), (("State contains sellAssetRequest=" + H) + " BUT no totalLocked"))
320+                    let bS = az(aA)
321+                    let bT = az((aA - 1))
322+                    let bU = ay()
323+                    if (if (if ((aA > bU))
324+                        then true
325+                        else (g > bS))
326+                        then true
327+                        else if ((bT != 0))
328+                            then (bT >= g)
329+                            else false)
330+                        then throw(((((((((("invalid price idx: idx=" + toString(aA)) + " currIdx=") + toString(bU)) + " idxHeight=") + toString(bS)) + " unlockHeight=") + toString(g)) + " prevIdxHeight=") + toString(bT)))
331+                        else {
332+                            let bV = aC(bS)
333+                            let bW = fromBase58String(u)
334+                            let bX = if ((bW == ap))
335+                                then {
336+                                    let bY = fraction(t, aq, bV)
337+                                    $Tuple4(bY, Reissue(al, bY, true), ScriptTransfer(addressFromStringValue(bN), bY, al), IntegerEntry(b(), (aG + t)))
338+                                    }
339+                                else if ((bW == al))
340+                                    then {
341+                                        let bZ = fraction(t, bV, aq)
342+                                        let ca = (aG - bZ)
343+                                        $Tuple4(bZ, Burn(ap, bZ), ScriptTransfer(addressFromStringValue(bN), bZ, ap), IntegerEntry(b(), (aG - bZ)))
344+                                        }
345+                                    else throw(("Unsupported assetIn=" + u))
346+                            let w = bX._1
347+                            let cb = bX._2
348+                            let cc = bX._3
349+                            let cd = bX._4
350+                            if ((0 > (bR - bP)))
351+                                then throw((("Invalid data state: " + bQ) + " less then 0"))
352+                                else ((([IntegerEntry(bQ, (bR - bP)), DeleteEntry(H), StringEntry(f(g, bN, "FINISHED"), s(t, u, bV, w, x, 0, 0))] :+ cb) :+ cc) :+ cd)
353+                            }
354+                    }
355+            }
356+    }
357+
358+
359+@Verifier(ce)
360+func cf () = {
361+    let cg = ce
362+    if ($isInstanceOf(cg, "InvokeScriptTransaction"))
363+        then {
364+            let ch = cg
365+            if ((ch.function != "rebalanceDebts"))
366+                then throw("only rebalanceDebts call is allowed")
367+                else if ((T(toString(addressFromRecipient(ch.dApp)))[X] != "ISSUED"))
368+                    then throw("only defo dapp is allowed")
369+                    else if ((ch.fee > (900 * 1000)))
370+                        then throw(("fee amount is greater than max allowed: " + toString(ch.fee)))
371+                        else if (isDefined(ch.feeAssetId))
372+                            then throw("only Waves is allowed as feeAssetId")
373+                            else true
374+            }
375+        else sigVerify(ce.bodyBytes, ce.proofs[0], ce.senderPublicKey)
376+    }
377+
github/deemru/w8io/026f985 
30.82 ms ◑