tx · 9aXugkWGEkPRK6SpH4LTpcAECJJSqBsJv4o6724riXSt

3MxWgDbE9EmjQj8b3LfFwa91FZizptyeQXS:  -0.08000000 Waves

2022.11.25 00:26 [2331710] smart account 3MxWgDbE9EmjQj8b3LfFwa91FZizptyeQXS > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "9aXugkWGEkPRK6SpH4LTpcAECJJSqBsJv4o6724riXSt",
    "fee": 8000000,
    "feeAssetId": null,
    "timestamp": 1669325135763,
    "version": 2,
    "chainId": 84,
    "sender": "3MxWgDbE9EmjQj8b3LfFwa91FZizptyeQXS",
    "senderPublicKey": "C7xgcYqQ8qV8rmvzAjhQWq4cz82F6VJfXMNygvrTXsfW",
    "proofs": [
        "3KsJTucKyM1SCiXyMyCvfpNUawkvTJWXNe2RLTGpAvukBpq9YjZGA5Zvxib23hPBjW6BoR99YUE5nwyNuWznwnvC",
        "MsPcpcrUyudP5S79z6LGaYDZn7Wz8HRyim8mNCZD5vAnMnPku386P1J6xsdL6MLSANoDUP7znAEpWBVwB8AuEH2"
    ],
    "script": "base64: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",
    "height": 2331710,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 45hJedv3552NyZDqW11cbB7HkKbTgt8t2wQFCcLsa2p6
Next: 6qhLkDFqMWisAhKUqnDMTwSTqtb6G7RCXdQuQytgVba5

Diff: 

OldNewDifferences
760760     }
761761 
762762 
763-func dq (dd,dr,ds,df) = if ((size(dd.payments) != 1))
764-    then throw("size(payments) != 1")
765-    else {
766-        let cJ = cF()
767-        if (cJ._1)
768-            then (cL(cJ._2) ++ cM(dd.originCaller, dd.payments))
769-            else {
770-                let dg = if ((size(dd.payments) > 0))
771-                    then if ((size(dd.payments) != 1))
772-                        then throw("size(payments) != 1")
763+func dq (dd,dr,ds,df) = {
764+    let cJ = cF()
765+    if (cJ._1)
766+        then (cL(cJ._2) ++ cM(dd.originCaller, dd.payments))
767+        else {
768+            let dg = if ((size(dd.payments) > 0))
769+                then {
770+                    let dh = dd.payments[0].assetId
771+                    if ((aa != dh))
772+                        then throw("unknown payment token")
773+                        else dd.payments[0].amount
774+                    }
775+                else 0
776+            let dt = valueOrErrorMessage(indexOf(aj, dr), "unknown token out")
777+            let du = fromBase58String(dr)
778+            let di = (dg + df)
779+            let aY = aM()
780+            let dv = bR(aY, di, dt, dd.originCaller)
781+            let cj = dv._1
782+            let dw = dv._2
783+            if (ax((cj >= ds)))
784+                then throw("Not enough coins removed")
785+                else {
786+                    let dx = fraction(dw, ae, ac)
787+                    let dy = (cj + dw)
788+                    func dz (aO,dA) =                     {
789+                        let dB = aO
790+                        let cQ = dB._1
791+                        let aq = dB._2
792+                        if ((aq == dt))
793+                            then $Tuple2((cQ :+ (dA - dy)), (aq + 1))
794+                            else $Tuple2((cQ :+ dA), (aq + 1))
795+                        }
796+
797+                    let dC = {
798+                        let aQ = aY
799+                        let aR = size(aQ)
800+                        let aS = $Tuple2(nil, 0)
801+                        func aT (aU,aV) =                         if ((aV >= aR))
802+                            then aU
803+                            else dz(aU, aQ[aV])
804+
805+                        func aW (aU,aV) =                         if ((aV >= aR))
806+                            then aU
807+                            else throw("List size exceeds 10")
808+
809+                        aW(aT(aT(aT(aT(aT(aT(aT(aT(aT(aT(aS, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
810+                        }
811+                    let cQ = dC._1
812+                    let dD = dC._2
813+                    if (cP(cQ))
814+                        then throw()
773815                         else {
774-                            let dh = dd.payments[0].assetId
775-                            if ((aa != dh))
776-                                then throw("unknown payment token")
777-                                else dd.payments[0].amount
816+                            let do = cA(dy, dr)
817+                            if ((do == do))
818+                                then {
819+                                    let dE = (dw - dx)
820+                                    let dF = if ((dE > 0))
821+                                        then invoke(V, "airDrop", nil, [AttachedPayment(du, dE)])
822+                                        else 0
823+                                    if ((dF == dF))
824+                                        then [ScriptTransfer(dd.originCaller, cj, du), IntegerEntry((aj[dt] + i), (aY[dt] - dy)), Burn(aa, di), ScriptTransfer(Q, dx, du), IntegerEntry(n, (ab - di))]
825+                                        else throw("Strict value is not equal to itself.")
826+                                    }
827+                                else throw("Strict value is not equal to itself.")
778828                             }
779-                    else 0
780-                let dt = valueOrErrorMessage(indexOf(aj, dr), "unknown token out")
781-                let du = fromBase58String(dr)
782-                let di = (dg + df)
783-                let aY = aM()
784-                let dv = bR(aY, di, dt, dd.originCaller)
785-                let cj = dv._1
786-                let dw = dv._2
787-                if (ax((cj >= ds)))
788-                    then throw("Not enough coins removed")
789-                    else {
790-                        let dx = fraction(dw, ae, ac)
791-                        let dy = (cj + dw)
792-                        func dz (aO,dA) =                         {
793-                            let dB = aO
794-                            let cQ = dB._1
795-                            let aq = dB._2
796-                            if ((aq == dt))
797-                                then $Tuple2((cQ :+ (dA - dy)), (aq + 1))
798-                                else $Tuple2((cQ :+ dA), (aq + 1))
799-                            }
800-
801-                        let dC = {
802-                            let aQ = aY
803-                            let aR = size(aQ)
804-                            let aS = $Tuple2(nil, 0)
805-                            func aT (aU,aV) =                             if ((aV >= aR))
806-                                then aU
807-                                else dz(aU, aQ[aV])
808-
809-                            func aW (aU,aV) =                             if ((aV >= aR))
810-                                then aU
811-                                else throw("List size exceeds 10")
812-
813-                            aW(aT(aT(aT(aT(aT(aT(aT(aT(aT(aT(aS, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
814-                            }
815-                        let cQ = dC._1
816-                        let dD = dC._2
817-                        if (cP(cQ))
818-                            then throw()
819-                            else {
820-                                let do = cA(dy, dr)
821-                                if ((do == do))
822-                                    then {
823-                                        let dE = (dw - dx)
824-                                        let dF = if ((dE > 0))
825-                                            then invoke(V, "airDrop", nil, [AttachedPayment(du, dE)])
826-                                            else 0
827-                                        if ((dF == dF))
828-                                            then [ScriptTransfer(dd.originCaller, cj, du), IntegerEntry((aj[dt] + i), (aY[dt] - dy)), Burn(aa, di), ScriptTransfer(Q, dx, du), IntegerEntry(n, (ab - di))]
829-                                            else throw("Strict value is not equal to itself.")
830-                                        }
831-                                    else throw("Strict value is not equal to itself.")
832-                                }
833-                        }
834-                }
835-        }
829+                    }
830+            }
831+    }
836832 
837833 
838834 @Callable(dd)
12221218 
12231219 
12241220 @Callable(dd)
1225-func withdrawOneCoin (dr,ds) = valueOrElse(ao(), dq(dd, dr, ds, 0))
1221+func withdrawOneCoin (dr,ds) = valueOrElse(ao(), if ((size(dd.payments) != 1))
1222+    then throw("size(payments) != 1")
1223+    else dq(dd, dr, ds, 0))
12261224 
12271225 
12281226 

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let a = 1000000
55 
66 let b = 1000000
77 
88 let c = 10
99 
1010 let d = 6
1111 
1212 let e = (86400 / 60)
1313 
1414 let f = "3.0.0"
1515 
1616 let g = "version"
1717 
1818 let h = "asset_ids"
1919 
2020 let i = "_balance"
2121 
2222 let j = "active"
2323 
2424 let k = "active_all_contracts"
2525 
2626 let l = "shutdown_cause"
2727 
2828 let m = "share_asset_id"
2929 
3030 let n = "share_asset_supply"
3131 
3232 let o = "commission"
3333 
3434 let p = "dAppThresholdCoef"
3535 
3636 let q = "staking_usdnnsbt_address"
3737 
3838 let r = "discounts"
3939 
4040 let s = "discount_values"
4141 
4242 let t = "_SWOP_amount"
4343 
4444 let u = "_GSwop_amount"
4545 
4646 let v = "admin_pub_1"
4747 
4848 let w = "admin_pub_2"
4949 
5050 let x = "admin_pub_3"
5151 
5252 let y = "admin_invoke_pub"
5353 
5454 let z = "money_box_address"
5555 
5656 let B = "governance_address"
5757 
5858 let C = "voting_address"
5959 
6060 let E = "farming_address"
6161 
6262 let F = "lp_farming"
6363 
6464 let G = Address(base58'3MvVBtsXroQpy1tsPw21TU2ET9A8WfmrNjz')
6565 
6666 func H (I) = {
6767     let J = getString(G, I)
6868     if ($isInstanceOf(J, "String"))
6969         then {
7070             let K = J
7171             fromBase58String(K)
7272             }
7373         else {
7474             let L = J
7575             throw((I + "is empty"))
7676             }
7777     }
7878 
7979 
8080 let M = H(v)
8181 
8282 let N = H(w)
8383 
8484 let O = H(x)
8585 
8686 let P = H(y)
8787 
8888 let Q = Address(H(z))
8989 
9090 let R = Address(H(B))
9191 
9292 let S = Address(H(q))
9393 
9494 let T = Address(H(C))
9595 
9696 let U = Address(H(E))
9797 
9898 let V = Address(H(F))
9999 
100100 let W = base58'8UrfDVd5GreeUwm7uPk7eYz1eMv376kzR52C6sANPkwS'
101101 
102102 let X = [toBase58String(W)]
103103 
104104 let Y = getBooleanValue(this, j)
105105 
106106 let Z = valueOrElse(getBoolean(G, k), true)
107107 
108108 let aa = fromBase58String(getStringValue(this, m))
109109 
110110 let ab = getIntegerValue(this, n)
111111 
112112 let ac = 1000000
113113 
114114 let ad = getIntegerValue(this, o)
115115 
116116 let ae = fraction(40, ac, 100)
117117 
118118 let af = getIntegerValue(this, "initial_A")
119119 
120120 let ag = getIntegerValue(this, "future_A")
121121 
122122 let ah = valueOrElse(getInteger(this, "initial_A_time"), 0)
123123 
124124 let ai = valueOrElse(getInteger(this, "future_A_time"), 0)
125125 
126126 let aj = split(getStringValue(this, h), ",")
127127 
128128 let ak = size(aj)
129129 
130130 func al (am) = [BooleanEntry(j, false), StringEntry(l, am)]
131131 
132132 
133133 func an () = throw("DApp is already active")
134134 
135135 
136136 func ao () = if (if (Y)
137137     then Z
138138     else false)
139139     then unit
140140     else throw("DApp is inactive at this moment")
141141 
142142 
143143 func ap (aq) = if (containsElement([M, N, O], aq.callerPublicKey))
144144     then unit
145145     else throw("Only admin can call this function")
146146 
147147 
148148 func ar (aq) = if ((this == aq.caller))
149149     then unit
150150     else throw("Only contract itself can call this function")
151151 
152152 
153153 let as = toBigInt(2)
154154 
155155 let at = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
156156 
157157 let au = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
158158 
159159 let av = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
160160 
161161 let aw = height
162162 
163163 func ax (ay) = if (ay)
164164     then false
165165     else true
166166 
167167 
168168 func az (aA) = {
169169     let aB = {
170170         let J = aA
171171         if ($isInstanceOf(J, "Address"))
172172             then {
173173                 let aC = J
174174                 toString(aC)
175175                 }
176176             else if ($isInstanceOf(J, "String"))
177177                 then {
178178                     let aC = J
179179                     aC
180180                     }
181181                 else throw("Unknow type of user Addr")
182182         }
183183     let aD = valueOrElse(getInteger(R, (aB + u)), 0)
184184     let aE = valueOrElse(getInteger(R, (aB + u)), aD)
185185     let aF = split(getStringValue(G, s), ",")
186186     let aG = split(getStringValue(G, r), ",")
187187     if (if ((aE >= parseIntValue(aF[0])))
188188         then (parseIntValue(aF[1]) > aE)
189189         else false)
190190         then (ac - parseIntValue(aG[0]))
191191         else if (if ((aE >= parseIntValue(aF[1])))
192192             then (parseIntValue(aF[2]) > aE)
193193             else false)
194194             then (ac - parseIntValue(aG[1]))
195195             else if (if ((aE >= parseIntValue(aF[2])))
196196                 then (parseIntValue(aF[3]) > aE)
197197                 else false)
198198                 then (ac - parseIntValue(aG[2]))
199199                 else if (if ((aE >= parseIntValue(aF[3])))
200200                     then (parseIntValue(aF[4]) > aE)
201201                     else false)
202202                     then (ac - parseIntValue(aG[3]))
203203                     else if ((aE >= parseIntValue(aF[4])))
204204                         then (ac - parseIntValue(aG[4]))
205205                         else ac
206206     }
207207 
208208 
209209 func aH () = {
210210     let aI = ai
211211     let aJ = ag
212212     if ((aI > aw))
213213         then {
214214             let aK = af
215215             let aL = ah
216216             if ((aJ > aK))
217217                 then (aK + (((aJ - aK) * (aw - aL)) / (aI - aL)))
218218                 else (aK - (((aK - aJ) * (aw - aL)) / (aI - aL)))
219219             }
220220         else aJ
221221     }
222222 
223223 
224224 func aM () = {
225225     func aN (aO,aP) =     (aO :+ valueOrElse(getInteger(this, (aP + i)), 0))
226226 
227227     let aQ = aj
228228     let aR = size(aQ)
229229     let aS = nil
230230     func aT (aU,aV) =     if ((aV >= aR))
231231         then aU
232232         else aN(aU, aQ[aV])
233233 
234234     func aW (aU,aV) =     if ((aV >= aR))
235235         then aU
236236         else throw("List size exceeds 10")
237237 
238238     aW(aT(aT(aT(aT(aT(aT(aT(aT(aT(aT(aS, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
239239     }
240240 
241241 
242242 func aX (aY) = aY
243243 
244244 
245245 func aZ (aO,ba) = (aO + ba)
246246 
247247 
248248 func bb (aY,bc) = {
249249     let bd = invoke(this, "D", [aY, bc], nil)
250250     if ($isInstanceOf(bd, "Int"))
251251         then bd
252252         else throw(($getType(bd) + " couldn't be cast to Int"))
253253     }
254254 
255255 
256256 func be (aY,bc) = {
257257     let bf = {
258258         let aQ = aY
259259         let aR = size(aQ)
260260         let aS = 0
261261         func aT (aU,aV) =         if ((aV >= aR))
262262             then aU
263263             else aZ(aU, aQ[aV])
264264 
265265         func aW (aU,aV) =         if ((aV >= aR))
266266             then aU
267267             else throw("List size exceeds 10")
268268 
269269         aW(aT(aT(aT(aT(aT(aT(aT(aT(aT(aT(aS, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
270270         }
271271     if ((bf == 0))
272272         then 0
273273         else {
274274             let bg = (bc * ak)
275275             let bh = (toBigInt(bg) * toBigInt(bf))
276276             let bi = toBigInt((bg - 1))
277277             func bj (aO,aq) =             if ((aO._2 == true))
278278                 then aO
279279                 else {
280280                     let bk = aO._1
281281                     func bl (bm,aq) =                     if ((ak > aq))
282282                         then ((bm * bk) / (toBigInt(aY[aq]) * toBigInt(ak)))
283283                         else bm
284284 
285285                     let bm = {
286286                         let aQ = at
287287                         let aR = size(aQ)
288288                         let aS = bk
289289                         func bn (aU,aV) =                         if ((aV >= aR))
290290                             then aU
291291                             else bl(aU, aQ[aV])
292292 
293293                         func bo (aU,aV) =                         if ((aV >= aR))
294294                             then aU
295295                             else throw("List size exceeds 10")
296296 
297297                         bo(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(aS, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
298298                         }
299299                     let bp = fraction((bh + (toBigInt(ak) * bm)), bk, ((bi * bk) + (toBigInt((ak + 1)) * bm)))
300300                     if ((bp > bk))
301301                         then if ((1 >= toInt((bp - bk))))
302302                             then $Tuple2(bp, true)
303303                             else $Tuple2(bp, false)
304304                         else if ((1 >= toInt((bk - bp))))
305305                             then $Tuple2(bp, true)
306306                             else $Tuple2(bp, false)
307307                     }
308308 
309309             let bq = {
310310                 let aQ = au
311311                 let aR = size(aQ)
312312                 let aS = $Tuple2(toBigInt(bf), false)
313313                 func bn (aU,aV) =                 if ((aV >= aR))
314314                     then aU
315315                     else bj(aU, aQ[aV])
316316 
317317                 func bo (aU,aV) =                 if ((aV >= aR))
318318                     then aU
319319                     else throw("List size exceeds 15")
320320 
321321                 bo(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(aS, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
322322                 }
323323             let bp = bq._1
324324             let br = bq._2
325325             if ((br == false))
326326                 then throw(("get_D() not finished with " + toString(bp)))
327327                 else toInt(bp)
328328             }
329329     }
330330 
331331 
332332 func bs (aY,bc) = bb(aX(aY), bc)
333333 
334334 
335335 func bt (bu,bv,bw,bx) = if (ax((bu != bv)))
336336     then throw("same coin")
337337     else if (ax(if ((bv >= 0))
338338         then (bu >= 0)
339339         else false))
340340         then throw("below zero")
341341         else if (ax(if ((ak > bv))
342342             then (ak > bu)
343343             else false))
344344             then throw("above N_COINS")
345345             else {
346346                 let bc = aH()
347347                 let bp = bb(bx, bc)
348348                 let bg = (bc * ak)
349349                 func by (aO,aq) =                 {
350350                     let bz = aO
351351                     let bA = bz._1
352352                     let bB = bz._2
353353                     let bC = if ((bu == aq))
354354                         then bw
355355                         else bx[aq]
356356                     if (if ((aq != bv))
357357                         then (ak > aq)
358358                         else false)
359359                         then $Tuple2((bA + bC), fraction(bB, toBigInt(bp), toBigInt((bC * ak))))
360360                         else $Tuple2(bA, bB)
361361                     }
362362 
363363                 let bD = {
364364                     let aQ = at
365365                     let aR = size(aQ)
366366                     let aS = $Tuple2(0, toBigInt(bp))
367367                     func aT (aU,aV) =                     if ((aV >= aR))
368368                         then aU
369369                         else by(aU, aQ[aV])
370370 
371371                     func aW (aU,aV) =                     if ((aV >= aR))
372372                         then aU
373373                         else throw("List size exceeds 10")
374374 
375375                     aW(aT(aT(aT(aT(aT(aT(aT(aT(aT(aT(aS, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
376376                     }
377377                 let bA = bD._1
378378                 let bE = bD._2
379379                 let bB = fraction(bE, toBigInt(bp), toBigInt((bg * ak)))
380380                 let bF = toBigInt(((bA + (bp / bg)) - bp))
381381                 func bG (aO,bH) =                 if ((aO._2 == true))
382382                     then aO
383383                     else {
384384                         let bI = aO._1
385385                         let bJ = (((bI * bI) + bB) / ((as * bI) + bF))
386386                         if ((bJ > bI))
387387                             then if ((1 >= toInt((bJ - bI))))
388388                                 then $Tuple2(bJ, true)
389389                                 else $Tuple2(bJ, false)
390390                             else if ((1 >= toInt((bI - bJ))))
391391                                 then $Tuple2(bJ, true)
392392                                 else $Tuple2(bJ, false)
393393                         }
394394 
395395                 let bK = {
396396                     let aQ = av
397397                     let aR = size(aQ)
398398                     let aS = $Tuple2(toBigInt(bp), false)
399399                     func bn (aU,aV) =                     if ((aV >= aR))
400400                         then aU
401401                         else bG(aU, aQ[aV])
402402 
403403                     func bo (aU,aV) =                     if ((aV >= aR))
404404                         then aU
405405                         else throw("List size exceeds 16")
406406 
407407                     bo(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(aS, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16)
408408                     }
409409                 let bJ = bK._1
410410                 let br = bK._2
411411                 if ((br == false))
412412                     then throw(("getY() not finished with " + toString(bJ)))
413413                     else toInt(bJ)
414414                 }
415415 
416416 
417417 func bL (bM,bu,aY,bp) = if (ax((bu >= 0)))
418418     then throw("i below zero")
419419     else if (ax((ak > bu)))
420420         then throw("i above N_COINS")
421421         else {
422422             let bg = (bM * ak)
423423             func by (aO,aq) =             {
424424                 let bN = aO
425425                 let bA = bN._1
426426                 let bB = bN._2
427427                 let bC = if (if ((bu != aq))
428428                     then (ak > aq)
429429                     else false)
430430                     then aY[aq]
431431                     else 0
432432                 if (if ((ak > aq))
433433                     then (bu != aq)
434434                     else false)
435435                     then $Tuple2((bA + bC), fraction(bB, toBigInt(bp), toBigInt((bC * ak))))
436436                     else $Tuple2(bA, bB)
437437                 }
438438 
439439             let bO = {
440440                 let aQ = at
441441                 let aR = size(aQ)
442442                 let aS = $Tuple2(0, toBigInt(bp))
443443                 func aT (aU,aV) =                 if ((aV >= aR))
444444                     then aU
445445                     else by(aU, aQ[aV])
446446 
447447                 func aW (aU,aV) =                 if ((aV >= aR))
448448                     then aU
449449                     else throw("List size exceeds 10")
450450 
451451                 aW(aT(aT(aT(aT(aT(aT(aT(aT(aT(aT(aS, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
452452                 }
453453             let bA = bO._1
454454             let bE = bO._2
455455             let bB = fraction(bE, toBigInt(bp), toBigInt((bg * ak)))
456456             let bF = toBigInt(((bA + (bp / bg)) - bp))
457457             func bP (aO,aq) =             if ((aO._2 == true))
458458                 then aO
459459                 else {
460460                     let bI = aO._1
461461                     let bJ = (((bI * bI) + bB) / ((as * bI) + bF))
462462                     if ((bJ > bI))
463463                         then if ((1 >= toInt((bJ - bI))))
464464                             then $Tuple2(bJ, true)
465465                             else $Tuple2(bJ, false)
466466                         else if ((1 >= toInt((bI - bJ))))
467467                             then $Tuple2(bJ, true)
468468                             else $Tuple2(bJ, false)
469469                     }
470470 
471471             let bQ = {
472472                 let aQ = av
473473                 let aR = size(aQ)
474474                 let aS = $Tuple2(toBigInt(bp), false)
475475                 func bn (aU,aV) =                 if ((aV >= aR))
476476                     then aU
477477                     else bP(aU, aQ[aV])
478478 
479479                 func bo (aU,aV) =                 if ((aV >= aR))
480480                     then aU
481481                     else throw("List size exceeds 16")
482482 
483483                 bo(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(aS, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16)
484484                 }
485485             let bJ = bQ._1
486486             let br = bQ._2
487487             if ((br == false))
488488                 then throw(("get_y_D() not finished with " + toString(bJ)))
489489                 else toInt(bJ)
490490             }
491491 
492492 
493493 func bR (aY,bS,aq,bT) = {
494494     let bU = az(bT)
495495     let bc = aH()
496496     let bV = ((fraction(ad, bU, ac, CEILING) * ak) / (4 * (ak - 1)))
497497     let bW = ab
498498     let bX = bb(aY, bc)
499499     let bY = (bX - fraction(bS, bX, bW))
500500     let bZ = bL(bc, aq, aY, bY)
501501     let ca = (aY[aq] - bZ)
502502     func cb (aO,cc) =     {
503503         let cd = aO
504504         let ce = cd._1
505505         let cf = cd._2
506506         let cg = if ((cf == aq))
507507             then (fraction(cc, bY, bX) - bZ)
508508             else (cc - fraction(cc, bY, bX))
509509         $Tuple2((ce :+ (cc - fraction(bV, cg, ac))), (cf + 1))
510510         }
511511 
512512     let ch = {
513513         let aQ = aY
514514         let aR = size(aQ)
515515         let aS = $Tuple2(nil, 0)
516516         func aT (aU,aV) =         if ((aV >= aR))
517517             then aU
518518             else cb(aU, aQ[aV])
519519 
520520         func aW (aU,aV) =         if ((aV >= aR))
521521             then aU
522522             else throw("List size exceeds 10")
523523 
524524         aW(aT(aT(aT(aT(aT(aT(aT(aT(aT(aT(aS, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
525525         }
526526     let ce = ch._1
527527     let cf = ch._2
528528     let ci = ce[aq]
529529     let cj = ((ci - bL(bc, aq, ce, bY)) - 1)
530530     $Tuple2(cj, (ca - cj))
531531     }
532532 
533533 
534534 func ck (aP) = {
535535     let J = aP
536536     if ($isInstanceOf(J, "ByteVector"))
537537         then {
538538             let cl = J
539539             toBase58String(cl)
540540             }
541541         else if ($isInstanceOf(J, "Unit"))
542542             then {
543543                 let cm = J
544544                 "WAVES"
545545                 }
546546             else throw("Match error")
547547     }
548548 
549549 
550550 func cn (co,aP) = if (co)
551551     then $Tuple2("lockNeutrino", S)
552552     else $Tuple2("unlockNeutrino", S)
553553 
554554 
555555 func cp (co,cq,aP) = if (co)
556556     then {
557557         let cr = cn(co, aP)
558558         let cs = cr._1
559559         let ct = cr._2
560560         $Tuple4(cs, ct, nil, [AttachedPayment(aP, cq)])
561561         }
562562     else {
563563         let cu = cn(co, aP)
564564         let cs = cu._1
565565         let ct = cu._2
566566         $Tuple4(cs, ct, [cq, toBase58String(aP)], nil)
567567         }
568568 
569569 
570570 func co (cq,cv) = if (containsElement(X, cv))
571571     then {
572572         let cw = cp(true, cq, fromBase58String(cv))
573573         let cs = cw._1
574574         let cx = cw._2
575575         let cy = cw._3
576576         let cz = cw._4
577577         invoke(cx, cs, cy, cz)
578578         }
579579     else 0
580580 
581581 
582582 func cA (cq,cv) = if (containsElement(X, cv))
583583     then {
584584         let cB = cp(false, cq, fromBase58String(cv))
585585         let cs = cB._1
586586         let cx = cB._2
587587         let cy = cB._3
588588         let cz = cB._4
589589         invoke(cx, cs, cy, cz)
590590         }
591591     else 0
592592 
593593 
594594 func cC (aP) = {
595595     let cD = {
596596         let J = aP
597597         if ($isInstanceOf(J, "ByteVector"))
598598             then {
599599                 let cE = J
600600                 if ((cE == W))
601601                     then getInteger(S, ((("rpd_balance_" + toBase58String(cE)) + "_") + toString(this)))
602602                     else 0
603603                 }
604604             else if ($isInstanceOf(J, "Unit"))
605605                 then 0
606606                 else throw("Match error")
607607         }
608608     let J = cD
609609     if ($isInstanceOf(J, "Int"))
610610         then {
611611             let aq = J
612612             aq
613613             }
614614         else 0
615615     }
616616 
617617 
618618 func cF () = {
619619     let cG = aM()
620620     func cH (aO,aP) =     {
621621         let cI = aO
622622         let cJ = cI._1
623623         let aq = cI._2
624624         if (cJ)
625625             then $Tuple2(cJ, aq)
626626             else {
627627                 let cK = (assetBalance(this, fromBase58String(aP)) + cC(fromBase58String(aP)))
628628                 if ((cG[aq] > cK))
629629                     then $Tuple2(true, aq)
630630                     else $Tuple2(false, (aq + 1))
631631                 }
632632         }
633633 
634634     let aQ = aj
635635     let aR = size(aQ)
636636     let aS = $Tuple2(false, 0)
637637     func aT (aU,aV) =     if ((aV >= aR))
638638         then aU
639639         else cH(aU, aQ[aV])
640640 
641641     func aW (aU,aV) =     if ((aV >= aR))
642642         then aU
643643         else throw("List size exceeds 10")
644644 
645645     aW(aT(aT(aT(aT(aT(aT(aT(aT(aT(aT(aS, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
646646     }
647647 
648648 
649649 func cL (aq) = al(("Suspicious state with asset: " + aj[aq]))
650650 
651651 
652652 func cM (bT,cz) = {
653653     func cN (aO,cO) =     (aO :+ ScriptTransfer(bT, cO.amount, cO.assetId))
654654 
655655     let aQ = cz
656656     let aR = size(aQ)
657657     let aS = nil
658658     func aT (aU,aV) =     if ((aV >= aR))
659659         then aU
660660         else cN(aU, aQ[aV])
661661 
662662     func aW (aU,aV) =     if ((aV >= aR))
663663         then aU
664664         else throw("List size exceeds 10")
665665 
666666     aW(aT(aT(aT(aT(aT(aT(aT(aT(aT(aT(aS, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
667667     }
668668 
669669 
670670 func cP (cQ) = {
671671     let cR = valueOrErrorMessage(getInteger(this, p), "No dAppThresholdCoef key")
672672     let cS = 10000
673673     let cT = max(cQ)
674674     let cU = min(cQ)
675675     let cV = fraction(cT, cS, cU)
676676     if ((cV > (cR * cS)))
677677         then throw("New balance in assets of the DApp is less than threshold")
678678         else false
679679     }
680680 
681681 
682682 func cW (aj) = {
683683     let cX = split(aj, ",")
684684     if ((size(cX) > 10))
685685         then throw("To many coins, max coins size 10")
686686         else {
687687             func cY (cZ,aP) =             {
688688                 let da = valueOrErrorMessage(fromBase58String(aP), ("fromBase58String: " + aP))
689689                 let db = valueOrErrorMessage(assetInfo(da), ("assetInfo: " + aP)).decimals
690690                 if ((db != d))
691691                     then throw("wrong decimals")
692692                     else false
693693                 }
694694 
695695             let aQ = cX
696696             let aR = size(aQ)
697697             let aS = false
698698             func aT (aU,aV) =             if ((aV >= aR))
699699                 then aU
700700                 else cY(aU, aQ[aV])
701701 
702702             func aW (aU,aV) =             if ((aV >= aR))
703703                 then aU
704704                 else throw("List size exceeds 10")
705705 
706706             aW(aT(aT(aT(aT(aT(aT(aT(aT(aT(aT(aS, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
707707             }
708708     }
709709 
710710 
711711 func dc (dd,de,df) = {
712712     let cJ = cF()
713713     if (cJ._1)
714714         then (cL(cJ._2) ++ cM(dd.caller, dd.payments))
715715         else {
716716             let dg = if ((size(dd.payments) > 0))
717717                 then if ((size(dd.payments) != 1))
718718                     then throw("size(payments) != 1")
719719                     else {
720720                         let dh = dd.payments[0].assetId
721721                         if ((aa != dh))
722722                             then throw("unknown payment token")
723723                             else dd.payments[0].amount
724724                         }
725725                 else 0
726726             let di = (dg + df)
727727             func dj (aO,dk) =             {
728728                 let dl = aO
729729                 let dm = dl._1
730730                 let aq = dl._2
731731                 let dn = fraction(dk, di, ab)
732732                 if (ax((dn >= de[aq])))
733733                     then throw("Withdrawal resulted in fewer coins than expected")
734734                     else {
735735                         let do = cA(dn, aj[aq])
736736                         if ((do == do))
737737                             then $Tuple2((dm ++ [IntegerEntry((aj[aq] + i), (dk - dn)), ScriptTransfer(dd.caller, dn, fromBase58String(aj[aq]))]), (aq + 1))
738738                             else throw("Strict value is not equal to itself.")
739739                         }
740740                 }
741741 
742742             let dp = {
743743                 let aQ = aM()
744744                 let aR = size(aQ)
745745                 let aS = $Tuple2(nil, 0)
746746                 func aT (aU,aV) =                 if ((aV >= aR))
747747                     then aU
748748                     else dj(aU, aQ[aV])
749749 
750750                 func aW (aU,aV) =                 if ((aV >= aR))
751751                     then aU
752752                     else throw("List size exceeds 10")
753753 
754754                 aW(aT(aT(aT(aT(aT(aT(aT(aT(aT(aT(aS, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
755755                 }
756756             let dm = dp._1
757757             let aq = dp._2
758758             (dm ++ [Burn(aa, di), IntegerEntry(n, (ab - di))])
759759             }
760760     }
761761 
762762 
763-func dq (dd,dr,ds,df) = if ((size(dd.payments) != 1))
764-    then throw("size(payments) != 1")
765-    else {
766-        let cJ = cF()
767-        if (cJ._1)
768-            then (cL(cJ._2) ++ cM(dd.originCaller, dd.payments))
769-            else {
770-                let dg = if ((size(dd.payments) > 0))
771-                    then if ((size(dd.payments) != 1))
772-                        then throw("size(payments) != 1")
763+func dq (dd,dr,ds,df) = {
764+    let cJ = cF()
765+    if (cJ._1)
766+        then (cL(cJ._2) ++ cM(dd.originCaller, dd.payments))
767+        else {
768+            let dg = if ((size(dd.payments) > 0))
769+                then {
770+                    let dh = dd.payments[0].assetId
771+                    if ((aa != dh))
772+                        then throw("unknown payment token")
773+                        else dd.payments[0].amount
774+                    }
775+                else 0
776+            let dt = valueOrErrorMessage(indexOf(aj, dr), "unknown token out")
777+            let du = fromBase58String(dr)
778+            let di = (dg + df)
779+            let aY = aM()
780+            let dv = bR(aY, di, dt, dd.originCaller)
781+            let cj = dv._1
782+            let dw = dv._2
783+            if (ax((cj >= ds)))
784+                then throw("Not enough coins removed")
785+                else {
786+                    let dx = fraction(dw, ae, ac)
787+                    let dy = (cj + dw)
788+                    func dz (aO,dA) =                     {
789+                        let dB = aO
790+                        let cQ = dB._1
791+                        let aq = dB._2
792+                        if ((aq == dt))
793+                            then $Tuple2((cQ :+ (dA - dy)), (aq + 1))
794+                            else $Tuple2((cQ :+ dA), (aq + 1))
795+                        }
796+
797+                    let dC = {
798+                        let aQ = aY
799+                        let aR = size(aQ)
800+                        let aS = $Tuple2(nil, 0)
801+                        func aT (aU,aV) =                         if ((aV >= aR))
802+                            then aU
803+                            else dz(aU, aQ[aV])
804+
805+                        func aW (aU,aV) =                         if ((aV >= aR))
806+                            then aU
807+                            else throw("List size exceeds 10")
808+
809+                        aW(aT(aT(aT(aT(aT(aT(aT(aT(aT(aT(aS, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
810+                        }
811+                    let cQ = dC._1
812+                    let dD = dC._2
813+                    if (cP(cQ))
814+                        then throw()
773815                         else {
774-                            let dh = dd.payments[0].assetId
775-                            if ((aa != dh))
776-                                then throw("unknown payment token")
777-                                else dd.payments[0].amount
816+                            let do = cA(dy, dr)
817+                            if ((do == do))
818+                                then {
819+                                    let dE = (dw - dx)
820+                                    let dF = if ((dE > 0))
821+                                        then invoke(V, "airDrop", nil, [AttachedPayment(du, dE)])
822+                                        else 0
823+                                    if ((dF == dF))
824+                                        then [ScriptTransfer(dd.originCaller, cj, du), IntegerEntry((aj[dt] + i), (aY[dt] - dy)), Burn(aa, di), ScriptTransfer(Q, dx, du), IntegerEntry(n, (ab - di))]
825+                                        else throw("Strict value is not equal to itself.")
826+                                    }
827+                                else throw("Strict value is not equal to itself.")
778828                             }
779-                    else 0
780-                let dt = valueOrErrorMessage(indexOf(aj, dr), "unknown token out")
781-                let du = fromBase58String(dr)
782-                let di = (dg + df)
783-                let aY = aM()
784-                let dv = bR(aY, di, dt, dd.originCaller)
785-                let cj = dv._1
786-                let dw = dv._2
787-                if (ax((cj >= ds)))
788-                    then throw("Not enough coins removed")
789-                    else {
790-                        let dx = fraction(dw, ae, ac)
791-                        let dy = (cj + dw)
792-                        func dz (aO,dA) =                         {
793-                            let dB = aO
794-                            let cQ = dB._1
795-                            let aq = dB._2
796-                            if ((aq == dt))
797-                                then $Tuple2((cQ :+ (dA - dy)), (aq + 1))
798-                                else $Tuple2((cQ :+ dA), (aq + 1))
799-                            }
800-
801-                        let dC = {
802-                            let aQ = aY
803-                            let aR = size(aQ)
804-                            let aS = $Tuple2(nil, 0)
805-                            func aT (aU,aV) =                             if ((aV >= aR))
806-                                then aU
807-                                else dz(aU, aQ[aV])
808-
809-                            func aW (aU,aV) =                             if ((aV >= aR))
810-                                then aU
811-                                else throw("List size exceeds 10")
812-
813-                            aW(aT(aT(aT(aT(aT(aT(aT(aT(aT(aT(aS, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
814-                            }
815-                        let cQ = dC._1
816-                        let dD = dC._2
817-                        if (cP(cQ))
818-                            then throw()
819-                            else {
820-                                let do = cA(dy, dr)
821-                                if ((do == do))
822-                                    then {
823-                                        let dE = (dw - dx)
824-                                        let dF = if ((dE > 0))
825-                                            then invoke(V, "airDrop", nil, [AttachedPayment(du, dE)])
826-                                            else 0
827-                                        if ((dF == dF))
828-                                            then [ScriptTransfer(dd.originCaller, cj, du), IntegerEntry((aj[dt] + i), (aY[dt] - dy)), Burn(aa, di), ScriptTransfer(Q, dx, du), IntegerEntry(n, (ab - di))]
829-                                            else throw("Strict value is not equal to itself.")
830-                                        }
831-                                    else throw("Strict value is not equal to itself.")
832-                                }
833-                        }
834-                }
835-        }
829+                    }
830+            }
831+    }
836832 
837833 
838834 @Callable(dd)
839835 func D (aY,bc) = {
840836     let bp = be(aY, bc)
841837     $Tuple2([IntegerEntry("D", bp)], bp)
842838     }
843839 
844840 
845841 
846842 @Callable(dd)
847843 func init (aj,aH,dG) = if (!(isDataStorageUntouched(this)))
848844     then throw("Already initialized")
849845     else if ((0 >= aH))
850846         then throw("Amp must be must > 0")
851847         else if ((0 >= dG))
852848             then throw("dApp Threshold Coef must be > 0")
853849             else {
854850                 let dH = "s_Multi_USD"
855851                 let dI = ("ShareToken of SwopFi protocol for MultiStable USD pool at address " + toString(this))
856852                 let dJ = Issue(dH, dI, 0, 6, true)
857853                 let dK = calculateAssetId(dJ)
858854                 if (cW(aj))
859855                     then throw()
860856                     else [StringEntry(g, f), StringEntry(h, aj), IntegerEntry("initial_A", aH), IntegerEntry("future_A", aH), IntegerEntry(o, getIntegerValue(G, "base_fee_flat")), StringEntry(m, toBase58String(dK)), IntegerEntry(n, 0), IntegerEntry(p, dG), BooleanEntry(j, true), dJ]
861857                 }
862858 
863859 
864860 
865861 @Callable(dd)
866862 func addLiquidity (dL,dM,dN) = valueOrElse(ao(), {
867863     let bc = aH()
868864     let aY = aM()
869865     let bX = if ((ab == 0))
870866         then 0
871867         else bs(aY, bc)
872868     let dO = if (if ((dN > 0))
873869         then (dd.payments[(size(dd.payments) - 1)].assetId == unit)
874870         else false)
875871         then $Tuple2(removeByIndex(dd.payments, (size(dd.payments) - 1)), [dd.payments[(size(dd.payments) - 1)]])
876872         else $Tuple2(dd.payments, nil)
877873     let cz = dO._1
878874     let dP = dO._2
879875     let dQ = size(cz)
880876     func dR (dS) =     if ((dQ > ak))
881877         then throw(("payments size > " + toString(ak)))
882878         else if ((1 > dQ))
883879             then throw("payments size < 1")
884880             else if (if ((ab == 0))
885881                 then (ak != dQ)
886882                 else false)
887883                 then throw("initial deposit requires all coins")
888884                 else {
889885                     func dT (aO,cO) =                     if (containsElement(aj, ck(cO.assetId)))
890886                         then true
891887                         else throw("Invalid asset in payment")
892888 
893889                     let aQ = cz
894890                     let aR = size(aQ)
895891                     let aS = false
896892                     func aT (aU,aV) =                     if ((aV >= aR))
897893                         then aU
898894                         else dT(aU, aQ[aV])
899895 
900896                     func aW (aU,aV) =                     if ((aV >= aR))
901897                         then aU
902898                         else throw("List size exceeds 10")
903899 
904900                     aW(aT(aT(aT(aT(aT(aT(aT(aT(aT(aT(aS, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
905901                     }
906902 
907903     if (!(dR(dQ)))
908904         then throw()
909905         else {
910906             let cJ = cF()
911907             if (cJ._1)
912908                 then (cL(cJ._2) ++ cM(dd.caller, cz))
913909                 else {
914910                     func cN (aO,aP) =                     {
915911                         let dU = aO
916912                         let cQ = dU._1
917913                         let aq = dU._2
918914                         func dV (dW,cO) =                         if ((ck(cO.assetId) == aP))
919915                             then (dW + cO.amount)
920916                             else dW
921917 
922918                         let dX = {
923919                             let aQ = cz
924920                             let aR = size(aQ)
925921                             let aS = aY[aq]
926922                             func aT (aU,aV) =                             if ((aV >= aR))
927923                                 then aU
928924                                 else dV(aU, aQ[aV])
929925 
930926                             func aW (aU,aV) =                             if ((aV >= aR))
931927                                 then aU
932928                                 else throw("List size exceeds 10")
933929 
934930                             aW(aT(aT(aT(aT(aT(aT(aT(aT(aT(aT(aS, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
935931                             }
936932                         $Tuple2((cQ :+ dX), (aq + 1))
937933                         }
938934 
939935                     let dY = {
940936                         let aQ = aj
941937                         let aR = size(aQ)
942938                         let aS = $Tuple2(nil, 0)
943939                         func aT (aU,aV) =                         if ((aV >= aR))
944940                             then aU
945941                             else cN(aU, aQ[aV])
946942 
947943                         func aW (aU,aV) =                         if ((aV >= aR))
948944                             then aU
949945                             else throw("List size exceeds 10")
950946 
951947                         aW(aT(aT(aT(aT(aT(aT(aT(aT(aT(aT(aS, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
952948                         }
953949                     let cQ = dY._1
954950                     let dZ = dY._2
955951                     if (cP(cQ))
956952                         then throw()
957953                         else {
958954                             let bY = bs(cQ, bc)
959955                             if (ax((bY > bX)))
960956                                 then throw("D1 > D0")
961957                                 else {
962958                                     let bU = az(dd.caller)
963959                                     func dj (aO,dW) =                                     {
964960                                         let ea = aO
965961                                         let eb = ea._1
966962                                         let dm = ea._2
967963                                         let aq = ea._3
968964                                         if ((ab > 0))
969965                                             then {
970966                                                 let bV = ((fraction(ad, bU, ac, CEILING) * ak) / (4 * (ak - 1)))
971967                                                 let ec = {
972968                                                     let ed = fraction(bY, aY[aq], bX)
973969                                                     let ee = if ((ed > dW))
974970                                                         then (ed - dW)
975971                                                         else (dW - ed)
976972                                                     fraction(bV, ee, ac)
977973                                                     }
978974                                                 let dx = fraction(ec, ae, ac)
979975                                                 let ef = (dW - ec)
980976                                                 let eg = (dW - ec)
981977                                                 let eh = (dW - aY[aq])
982978                                                 let dE = (ec - dx)
983979                                                 let ei = if ((eh > 0))
984980                                                     then co((eh - ec), aj[aq])
985981                                                     else cA(ec, aj[aq])
986982                                                 if ((ei == ei))
987983                                                     then {
988984                                                         let dF = if ((dE > 0))
989985                                                             then invoke(V, "airDrop", nil, [AttachedPayment(fromBase58String(aj[aq]), dE)])
990986                                                             else 0
991987                                                         if ((dF == dF))
992988                                                             then $Tuple3((eb :+ eg), (dm ++ [ScriptTransfer(Q, dx, fromBase58String(aj[aq])), IntegerEntry((aj[aq] + i), ef)]), (aq + 1))
993989                                                             else throw("Strict value is not equal to itself.")
994990                                                         }
995991                                                     else throw("Strict value is not equal to itself.")
996992                                                 }
997993                                             else {
998994                                                 let ei = co(dW, aj[aq])
999995                                                 if ((ei == ei))
1000996                                                     then $Tuple3((eb :+ dW), (dm :+ IntegerEntry((aj[aq] + i), dW)), (aq + 1))
1001997                                                     else throw("Strict value is not equal to itself.")
1002998                                                 }
1003999                                         }
10041000 
10051001                                     let ej = {
10061002                                         let aQ = cQ
10071003                                         let aR = size(aQ)
10081004                                         let aS = $Tuple3(nil, nil, 0)
10091005                                         func bn (aU,aV) =                                         if ((aV >= aR))
10101006                                             then aU
10111007                                             else dj(aU, aQ[aV])
10121008 
10131009                                         func bo (aU,aV) =                                         if ((aV >= aR))
10141010                                             then aU
10151011                                             else throw("List size exceeds 10")
10161012 
10171013                                         bo(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(aS, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
10181014                                         }
10191015                                     let eb = ej._1
10201016                                     let dm = ej._2
10211017                                     let ek = bs(eb, bc)
10221018                                     let el = if ((ab == 0))
10231019                                         then bY
10241020                                         else fraction(ab, (ek - bX), bX)
10251021                                     if (ax((el >= dL)))
10261022                                         then throw("Slippage screwed you")
10271023                                         else if (dM)
10281024                                             then {
10291025                                                 let em = invoke(this, "reissueShare", [el], nil)
10301026                                                 if ((em == em))
10311027                                                     then {
10321028                                                         let en = invoke(U, "lockShareTokensFromPool", [dd.caller.bytes, toString(this), dN], ([AttachedPayment(aa, el)] ++ dP))
10331029                                                         if ((en == en))
10341030                                                             then (dm :+ IntegerEntry(n, (ab + el)))
10351031                                                             else throw("Strict value is not equal to itself.")
10361032                                                         }
10371033                                                     else throw("Strict value is not equal to itself.")
10381034                                                 }
10391035                                             else (dm ++ [Reissue(aa, el, true), ScriptTransfer(dd.caller, el, aa), IntegerEntry(n, (ab + el))])
10401036                                     }
10411037                             }
10421038                     }
10431039             }
10441040     })
10451041 
10461042 
10471043 
10481044 @Callable(dd)
10491045 func calcMintAmount (cQ,aB) = {
10501046     let bc = aH()
10511047     let aY = aM()
10521048     let bY = bs(cQ, bc)
10531049     if ((ab == 0))
10541050         then $Tuple2(nil, bY)
10551051         else {
10561052             let bX = bs(aY, bc)
10571053             let bU = az(aB)
10581054             func eo (aO,dW) =             {
10591055                 let ep = aO
10601056                 let eb = ep._1
10611057                 let aq = ep._2
10621058                 let bV = ((fraction(ad, bU, ac, CEILING) * ak) / (4 * (ak - 1)))
10631059                 let ec = {
10641060                     let ed = fraction(bY, aY[aq], bX)
10651061                     let ee = if ((ed > dW))
10661062                         then (ed - dW)
10671063                         else (dW - ed)
10681064                     fraction(bV, ee, ac)
10691065                     }
10701066                 let eg = (dW - ec)
10711067                 $Tuple2((eb :+ eg), (aq + 1))
10721068                 }
10731069 
10741070             let eq = {
10751071                 let aQ = cQ
10761072                 let aR = size(aQ)
10771073                 let aS = $Tuple2(nil, 0)
10781074                 func aT (aU,aV) =                 if ((aV >= aR))
10791075                     then aU
10801076                     else eo(aU, aQ[aV])
10811077 
10821078                 func aW (aU,aV) =                 if ((aV >= aR))
10831079                     then aU
10841080                     else throw("List size exceeds 10")
10851081 
10861082                 aW(aT(aT(aT(aT(aT(aT(aT(aT(aT(aT(aS, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
10871083                 }
10881084             let eb = eq._1
10891085             let dZ = eq._2
10901086             let ek = bs(eb, bc)
10911087             let er = fraction(ab, (ek - bX), bX)
10921088             $Tuple2(nil, er)
10931089             }
10941090     }
10951091 
10961092 
10971093 
10981094 @Callable(dd)
10991095 func reissueShare (cq) = valueOrElse(ar(dd), [Reissue(aa, cq, true)])
11001096 
11011097 
11021098 
11031099 @Callable(dd)
11041100 func getDy (es,et,eu,ev) = {
11051101     let aY = aM()
11061102     let ew = valueOrErrorMessage(indexOf(aj, es), "unknown token in")
11071103     let ex = valueOrErrorMessage(indexOf(aj, et), "unknown token out")
11081104     let bw = (aY[ew] + eu)
11091105     let bJ = bt(ew, ex, bw, aY)
11101106     let cj = ((aY[ex] - bJ) - 1)
11111107     let bU = az(Address(fromBase58String(ev)))
11121108     let bV = fraction(fraction(ad, bU, ac, CEILING), cj, ac)
11131109     $Tuple2(nil, $Tuple2((cj - bV), bV))
11141110     }
11151111 
11161112 
11171113 
11181114 @Callable(dd)
11191115 func exchange (dr,ey) = valueOrElse(ao(), if ((size(dd.payments) != 1))
11201116     then throw("size(payments) != 1")
11211117     else {
11221118         let cJ = cF()
11231119         if (cJ._1)
11241120             then (cL(cJ._2) ++ cM(dd.caller, dd.payments))
11251121             else {
11261122                 let cO = dd.payments[0]
11271123                 let ez = ck(cO.assetId)
11281124                 let du = fromBase58String(dr)
11291125                 let eu = cO.amount
11301126                 let ew = valueOrErrorMessage(indexOf(aj, ez), "unknown token in")
11311127                 let ex = valueOrErrorMessage(indexOf(aj, dr), "unknown token out")
11321128                 let aY = aM()
11331129                 let bw = (aY[ew] + eu)
11341130                 let bJ = bt(ew, ex, bw, aY)
11351131                 let eA = ((aY[ex] - bJ) - 1)
11361132                 let bU = az(dd.originCaller)
11371133                 let bV = fraction(eA, fraction(ad, bU, ac, CEILING), ac)
11381134                 let cj = (eA - bV)
11391135                 let dx = fraction(bV, ae, ac)
11401136                 if (ax((cj >= ey)))
11411137                     then throw("Exchange resulted in fewer coins than expected")
11421138                     else {
11431139                         func dz (aO,dA) =                         {
11441140                             let eB = aO
11451141                             let cQ = eB._1
11461142                             let aq = eB._2
11471143                             if ((aq == ew))
11481144                                 then $Tuple2((cQ :+ (dA + eu)), (aq + 1))
11491145                                 else if ((aq == ex))
11501146                                     then $Tuple2((cQ :+ (dA - eA)), (aq + 1))
11511147                                     else $Tuple2((cQ :+ dA), (aq + 1))
11521148                             }
11531149 
11541150                         let eC = {
11551151                             let aQ = aY
11561152                             let aR = size(aQ)
11571153                             let aS = $Tuple2(nil, 0)
11581154                             func aT (aU,aV) =                             if ((aV >= aR))
11591155                                 then aU
11601156                                 else dz(aU, aQ[aV])
11611157 
11621158                             func aW (aU,aV) =                             if ((aV >= aR))
11631159                                 then aU
11641160                                 else throw("List size exceeds 10")
11651161 
11661162                             aW(aT(aT(aT(aT(aT(aT(aT(aT(aT(aT(aS, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
11671163                             }
11681164                         let cQ = eC._1
11691165                         let aq = eC._2
11701166                         if (cP(cQ))
11711167                             then throw()
11721168                             else {
11731169                                 let en = co(cO.amount, ck(cO.assetId))
11741170                                 if ((en == en))
11751171                                     then {
11761172                                         let do = cA(eA, dr)
11771173                                         if ((do == do))
11781174                                             then {
11791175                                                 let dE = (bV - dx)
11801176                                                 let dF = if ((dE > 0))
11811177                                                     then invoke(V, "airDrop", nil, [AttachedPayment(du, dE)])
11821178                                                     else 0
11831179                                                 if ((dF == dF))
11841180                                                     then $Tuple2([IntegerEntry((ez + i), bw), IntegerEntry((dr + i), (aY[ex] - eA)), ScriptTransfer(dd.caller, cj, du), ScriptTransfer(Q, dx, du)], [cj, du])
11851181                                                     else throw("Strict value is not equal to itself.")
11861182                                                 }
11871183                                             else throw("Strict value is not equal to itself.")
11881184                                         }
11891185                                     else throw("Strict value is not equal to itself.")
11901186                                 }
11911187                         }
11921188                 }
11931189         })
11941190 
11951191 
11961192 
11971193 @Callable(dd)
11981194 func withdraw (de) = valueOrElse(ao(), dc(dd, de, 0))
11991195 
12001196 
12011197 
12021198 @Callable(dd)
12031199 func withdrawWithUnlock (de,df) = valueOrElse(ao(), if ((0 >= df))
12041200     then throw("Unlock amount must be positive")
12051201     else {
12061202         let eD = invoke(U, "withdrawShareTokensFromPool", [dd.caller.bytes, toString(this), df], nil)
12071203         if ((eD == eD))
12081204             then dc(dd, de, df)
12091205             else throw("Strict value is not equal to itself.")
12101206         })
12111207 
12121208 
12131209 
12141210 @Callable(dd)
12151211 func calcWithdrawOneCoin (eE,dr,aB) = if ((0 >= eE))
12161212     then throw("Amount must be positive")
12171213     else {
12181214         let aq = valueOrErrorMessage(indexOf(aj, dr), "unknown token out")
12191215         $Tuple2(nil, bR(aM(), eE, aq, Address(fromBase58String(aB)))._1)
12201216         }
12211217 
12221218 
12231219 
12241220 @Callable(dd)
1225-func withdrawOneCoin (dr,ds) = valueOrElse(ao(), dq(dd, dr, ds, 0))
1221+func withdrawOneCoin (dr,ds) = valueOrElse(ao(), if ((size(dd.payments) != 1))
1222+    then throw("size(payments) != 1")
1223+    else dq(dd, dr, ds, 0))
12261224 
12271225 
12281226 
12291227 @Callable(dd)
12301228 func withdrawOneCoinWithUnlock (dr,ds,df) = valueOrElse(ao(), if ((0 >= df))
12311229     then throw("Unlock amount must be positive")
12321230     else {
12331231         let eD = invoke(U, "withdrawShareTokensFromPool", [dd.caller.bytes, toString(this), df], nil)
12341232         if ((eD == eD))
12351233             then dq(dd, dr, ds, df)
12361234             else throw("Strict value is not equal to itself.")
12371235         })
12381236 
12391237 
12401238 
12411239 @Callable(dd)
12421240 func A () = $Tuple2(nil, aH())
12431241 
12441242 
12451243 
12461244 @Callable(dd)
12471245 func getVirtualPrice () = {
12481246     let bp = bb(aM(), aH())
12491247     $Tuple2(nil, fraction(bp, a, ab))
12501248     }
12511249 
12521250 
12531251 
12541252 @Callable(dd)
12551253 func calcTokenAmount (eF,eG) = {
12561254     let bc = aH()
12571255     let eH = aM()
12581256     let bX = bs(eH, bc)
12591257     func eI (aO,dk) =     {
12601258         let eJ = aO
12611259         let cQ = eJ._1
12621260         let aq = eJ._2
12631261         let dW = (dk + (if (eG)
12641262             then eF[aq]
12651263             else -(eF[aq])))
12661264         $Tuple2((cQ :+ dW), (aq + 1))
12671265         }
12681266 
12691267     let cQ = (    let aQ = eH
12701268     let aR = size(aQ)
12711269     let aS = $Tuple2(nil, 0)
12721270     func aT (aU,aV) =     if ((aV >= aR))
12731271         then aU
12741272         else eI(aU, aQ[aV])
12751273 
12761274     func aW (aU,aV) =     if ((aV >= aR))
12771275         then aU
12781276         else throw("List size exceeds 10")
12791277 
12801278     aW(aT(aT(aT(aT(aT(aT(aT(aT(aT(aT(aS, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10))._1
12811279     let bY = bs(cQ, bc)
12821280     let eK = if (eG)
12831281         then (bY - bX)
12841282         else (bX - bY)
12851283     $Tuple2(nil, fraction(eK, ab, bX))
12861284     }
12871285 
12881286 
12891287 
12901288 @Callable(dd)
12911289 func rampA (eL,eM) = valueOrElse(ao(), valueOrElse(ap(dd), if (ax((aw >= (ah + e))))
12921290     then throw("too often")
12931291     else if (ax((eM >= (aw + e))))
12941292         then throw("insufficient time")
12951293         else {
12961294             let eN = aH()
12971295             if (ax(if ((eL > 0))
12981296                 then (b > eL)
12991297                 else false))
13001298                 then throw("out of base range")
13011299                 else if (ax(if (if ((eL >= eN))
13021300                     then ((eN * c) >= eL)
13031301                     else false)
13041302                     then true
13051303                     else if ((eN > eL))
13061304                         then ((eL * c) >= eN)
13071305                         else false))
13081306                     then throw("out of range")
13091307                     else [IntegerEntry("initial_A", eN), IntegerEntry("future_A", eL), IntegerEntry("initial_A_time", aw), IntegerEntry("future_A_time", eM)]
13101308             }))
13111309 
13121310 
13131311 
13141312 @Callable(dd)
13151313 func stopRampA () = valueOrElse(ao(), valueOrElse(ap(dd), {
13161314     let eO = aH()
13171315 [IntegerEntry("initial_A", eO), IntegerEntry("future_A", eO), IntegerEntry("initial_A_time", aw), IntegerEntry("future_A_time", aw)]
13181316     }))
13191317 
13201318 
13211319 
13221320 @Callable(dd)
13231321 func shutdown () = valueOrElse(ap(dd), if (!(Y))
13241322     then throw(("DApp is already suspended. Cause: " + valueOrElse(getString(this, l), "the cause wasn't specified")))
13251323     else al("Paused by admin"))
13261324 
13271325 
13281326 
13291327 @Callable(dd)
13301328 func activate () = valueOrElse(ap(dd), if (Y)
13311329     then an()
13321330     else [BooleanEntry(j, true), DeleteEntry(l)])
13331331 
13341332 
13351333 
13361334 @Callable(dd)
13371335 func takeIntoAccountExtraFunds () = valueOrElse(ao(), if ((dd.caller != Q))
13381336     then throw("Only the wallet can call this function")
13391337     else {
13401338         let eH = aM()
13411339         func eP (aO,aP) =         {
13421340             let eQ = aO
13431341             let eR = eQ._1
13441342             let aq = eQ._2
13451343             let eS = fromBase58String(aP)
13461344             let eT = (assetBalance(this, eS) + cC(eS))
13471345             let eU = (eT - eH[aq])
13481346             if ((0 > eU))
13491347                 then al(("Enroll amount negative for asset" + aP))
13501348                 else {
13511349                     let dF = if ((eU > 0))
13521350                         then invoke(V, "airDrop", nil, [AttachedPayment(eS, eU)])
13531351                         else 0
13541352                     if ((dF == dF))
13551353                         then $Tuple2((eR + eU), (aq + 1))
13561354                         else throw("Strict value is not equal to itself.")
13571355                     }
13581356             }
13591357 
13601358         let dZ = {
13611359             let aQ = aj
13621360             let aR = size(aQ)
13631361             let aS = $Tuple2(0, 0)
13641362             func aT (aU,aV) =             if ((aV >= aR))
13651363                 then aU
13661364                 else eP(aU, aQ[aV])
13671365 
13681366             func aW (aU,aV) =             if ((aV >= aR))
13691367                 then aU
13701368                 else throw("List size exceeds 10")
13711369 
13721370             aW(aT(aT(aT(aT(aT(aT(aT(aT(aT(aT(aS, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
13731371             }
13741372         if ((dZ._1 == 0))
13751373             then throw("No money to take")
13761374             else nil
13771375         })
13781376 
13791377 
13801378 @Verifier(eV)
13811379 func eW () = {
13821380     let eX = {
13831381         let eY = if (sigVerify(eV.bodyBytes, eV.proofs[0], M))
13841382             then 1
13851383             else 0
13861384         let eZ = if (sigVerify(eV.bodyBytes, eV.proofs[1], N))
13871385             then 1
13881386             else 0
13891387         let fa = if (sigVerify(eV.bodyBytes, eV.proofs[2], O))
13901388             then 1
13911389             else 0
13921390         (((eY + eZ) + fa) >= 2)
13931391         }
13941392     let J = eV
13951393     if ($isInstanceOf(J, "InvokeScriptTransaction"))
13961394         then {
13971395             let ei = J
13981396             let fb = if ((ei.dApp == this))
13991397                 then (ei.function == "takeIntoAccountExtraFunds")
14001398                 else false
14011399             let fc = if (if (if (sigVerify(eV.bodyBytes, eV.proofs[0], M))
14021400                 then true
14031401                 else sigVerify(eV.bodyBytes, eV.proofs[0], N))
14041402                 then true
14051403                 else sigVerify(eV.bodyBytes, eV.proofs[0], O))
14061404                 then true
14071405                 else sigVerify(eV.bodyBytes, eV.proofs[0], P)
14081406             if (if (fb)
14091407                 then fc
14101408                 else false)
14111409                 then true
14121410                 else eX
14131411             }
14141412         else eX
14151413     }
14161414 
github/deemru/w8io/026f985 
144.92 ms ◑