2022.08.09 16:56 [3242502] smart account 3PPKvu6x52MFaMGfw3i2byPVXXBuH7FTNMU > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "214eimD8WL43FoBwAFPMb4kAMcbigQutbKN8EQhApAwk",
    "fee": 1200000,
    "feeAssetId": null,
    "timestamp": 1660053426953,
    "version": 2,
    "chainId": 87,
    "sender": "3PPKvu6x52MFaMGfw3i2byPVXXBuH7FTNMU",
    "senderPublicKey": "2EkX192CHj7Ut47LgFMd3Pg7U7rhQFJhKgcr3rD5Dtig",
    "proofs": [
        "613j9YSgsa3r1NG8CYnJ8kQqsdUvfPSpBbzuaNN8EdJAjnMcJaMd91SUPKB9Jd66gYXP3Dcuxk6GY4bgAtc7xy1G"
    ],
    "script": "base64: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",
    "height": 3242502,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: D9qp1uAJ6gVvkMa3qmg3muF8nfP35tQhfrurwaR4vWCz
Next: kAjU212EN2jCe5gsbDgDSBh98dfkv4kjLmFVCcaS9fB

Diff: 
Old
New
Differences
122
122
 
                                then parentLpPrice
123
123
 
                                else throw("Strict value is not equal to itself.")
124
124
 
                            }
125
-
                    let inv = if ((assetIdStr == parentLpIdStr))
126
-
                        then unit
127
-
                        else if (evaluation)
128
-
                            then calcSwap(assetIdStr, amountToBuyback)
129
-
                            else invoke(poolAddress, "swap", [plutoIdStr, 0], [AttachedPayment(assetId, amountToBuyback)])
130
-
                    if ((inv == inv))
125
+
                    if ((assetPriceToPluto == assetPriceToPluto))
131
126
 
                        then {
132
-
                            let plutoBought =                             match inv {
133
-
                                case x: Int => 
134
-
                                    x
135
-
                                case _ => 
136
-
                                    0
137
-
                            }
138
-
                            let plutoIssued = fraction(amountToIssue, assetPriceToPluto, Scale8)
139
-
                            let totalPluto = (plutoBought + plutoIssued)
140
-
                            let premiumPlutoIssued = fraction(totalPluto, premium, 10000)
141
-
                            let teamPlutoIssued = fraction(totalPluto, teamPremium, 10000)
142
-
                            let inv2 = invoke(issuerAddress, "requestIssue", [((plutoIssued + premiumPlutoIssued) + teamPlutoIssued)], nil)
143
-
                            if ((inv2 == inv2))
144
-
                                then [plutoIssued, plutoBought, premiumPlutoIssued, teamPlutoIssued, amountToIssue, premium, period]
127
+
                            let inv = if ((assetIdStr == parentLpIdStr))
128
+
                                then unit
129
+
                                else if (evaluation)
130
+
                                    then calcSwap(assetIdStr, amountToBuyback)
131
+
                                    else invoke(poolAddress, "swap", [plutoIdStr, 0], [AttachedPayment(assetId, amountToBuyback)])
132
+
                            if ((inv == inv))
133
+
                                then {
134
+
                                    let plutoBought =                                     match inv {
135
+
                                        case x: Int => 
136
+
                                            x
137
+
                                        case _ => 
138
+
                                            0
139
+
                                    }
140
+
                                    let plutoIssued = fraction(amountToIssue, assetPriceToPluto, Scale8)
141
+
                                    let totalPluto = (plutoBought + plutoIssued)
142
+
                                    let premiumPlutoIssued = fraction(totalPluto, premium, 10000)
143
+
                                    let teamPlutoIssued = fraction(totalPluto, teamPremium, 10000)
144
+
                                    let inv2 = invoke(issuerAddress, "requestIssue", [((plutoIssued + premiumPlutoIssued) + teamPlutoIssued)], nil)
145
+
                                    if ((inv2 == inv2))
146
+
                                        then [plutoIssued, plutoBought, premiumPlutoIssued, teamPlutoIssued, amountToIssue, premium, period]
147
+
                                        else throw("Strict value is not equal to itself.")
148
+
                                    }
145
149
 
                                else throw("Strict value is not equal to itself.")
146
150
 
                            }
147
151
 
                        else throw("Strict value is not equal to itself.")
Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 5 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
let plutoId = base58'Ajso6nTTjptu2UHLx6hfSXVtHFtRBJCkKYd5SAyj7zf5'
5
5
 
6
6
 
let plutoIdStr = "Ajso6nTTjptu2UHLx6hfSXVtHFtRBJCkKYd5SAyj7zf5"
7
7
 
8
8
 
let parametersAddress = Address(base58'3P3a1jssxc2CGdyC7SGbTJc9ZvTjZ5jBMLZ')
9
9
 
10
10
 
let stakingAddress = Address(base58'3P7dGTVZp8VLDYy3XEaUQbiqfi9cMK1Ly5q')
11
11
 
12
12
 
let issuerAddress = Address(base58'3PCRXK4q3SWK3TfjTgYc88x3jr8semrHLJs')
13
13
 
14
14
 
let treasuryAddress = Address(base58'3PKFFFsiKR7rgaeoLQZj6jLsxteZigccN8h')
15
15
 
16
16
 
let teamAddress = Address(base58'3P8XyUj7seSjJc6gqDgM9MxAfmnmcDAE6gj')
17
17
 
18
18
 
let poolAddress = Address(base58'3P93Kqz8PUbCudvMyjbci54WxQrtBtw4dbZ')
19
19
 
20
20
 
let parentLpIdStr = "BNXTKjftTy5zZEozFdkqDTTiru7guvunLiCpZuTAaC4h"
21
21
 
22
22
 
let parentLpId = base58'BNXTKjftTy5zZEozFdkqDTTiru7guvunLiCpZuTAaC4h'
23
23
 
24
24
 
let treasuryAssets = ["DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p", "6XtHjpXbs9RRJP2Sr9GUyVqzACcby9TkThHXnjVC5CDJ", "34N9YcEETLWn93qYQ64EsP1x89tSruJU44RrEMSXXEPJ"]
25
25
 
26
26
 
let Scale8 = 100000000
27
27
 
28
28
 
func tryGetInteger (key) = match getInteger(this, key) {
29
29
 
    case x: Int => 
30
30
 
        x
31
31
 
    case _ => 
32
32
 
        0
33
33
 
}
34
34
 
35
35
 
36
36
 
func tryGetIntParameter (key) = match getInteger(parametersAddress, key) {
37
37
 
    case x: Int => 
38
38
 
        x
39
39
 
    case _ => 
40
40
 
        0
41
41
 
}
42
42
 
43
43
 
44
44
 
func tryGetStrParameter (key) = match getString(parametersAddress, key) {
45
45
 
    case x: String => 
46
46
 
        x
47
47
 
    case _ => 
48
48
 
        ""
49
49
 
}
50
50
 
51
51
 
52
52
 
func calculatePoolPrice (poolAddress,assetStr) = {
53
53
 
    let a0Weight = getIntegerValue(poolAddress, (("static_" + assetStr) + "_weight"))
54
54
 
    let a1Weight = getIntegerValue(poolAddress, (("static_" + plutoIdStr) + "_weight"))
55
55
 
    let a0Balance = getIntegerValue(poolAddress, (("global_" + assetStr) + "_balance"))
56
56
 
    let a1Balance = getIntegerValue(poolAddress, (("global_" + plutoIdStr) + "_balance"))
57
57
 
    fraction(Scale8, (a1Balance * a0Weight), (a0Balance * a1Weight))
58
58
 
    }
59
59
 
60
60
 
61
61
 
func calcSwap (assetStr,amount) = {
62
62
 
    let a0Weight = getIntegerValue(poolAddress, (("static_" + assetStr) + "_weight"))
63
63
 
    let a1Weight = getIntegerValue(poolAddress, (("static_" + plutoIdStr) + "_weight"))
64
64
 
    let a0Balance = getIntegerValue(poolAddress, (("global_" + assetStr) + "_balance"))
65
65
 
    let a1Balance = getIntegerValue(poolAddress, (("global_" + plutoIdStr) + "_balance"))
66
66
 
    let amount1 = fraction(a1Balance, ((Scale8 * Scale8) - toInt(pow(fraction(toBigInt(a0Balance), toBigInt((Scale8 * Scale8)), toBigInt((a0Balance + amount)), HALFUP), 16, toBigInt(fraction(a0Weight, 10000, a1Weight)), 4, 16, CEILING))), (Scale8 * Scale8), DOWN)
67
67
 
    fraction(amount1, 98, 100)
68
68
 
    }
69
69
 
70
70
 
71
71
 
func calculateIssuePluto (assetId,amount,evaluation) = {
72
72
 
    let assetIdStr = toBase58String(assetId)
73
73
 
    if ((indexOf(treasuryAssets, assetIdStr) == unit))
74
74
 
        then throw("asset not supported")
75
75
 
        else {
76
76
 
            let onboardingParameters =             match invoke(parametersAddress, "getOnboardingParameters", [false], nil) {
77
77
 
                case in: List[Any] => 
78
78
 
                    in
79
79
 
                case _ => 
80
80
 
                    throw("cannot load parameters")
81
81
 
            }
82
82
 
            if ((onboardingParameters == onboardingParameters))
83
83
 
                then {
84
84
 
                    let buybackRatio =                     match onboardingParameters[4] {
85
85
 
                        case x: Int => 
86
86
 
                            x
87
87
 
                        case _ => 
88
88
 
                            throw("cannot parse parameters")
89
89
 
                    }
90
90
 
                    let premium =                     match onboardingParameters[1] {
91
91
 
                        case x: Int => 
92
92
 
                            x
93
93
 
                        case _ => 
94
94
 
                            throw("cannot parse parameters")
95
95
 
                    }
96
96
 
                    let teamPremium =                     match onboardingParameters[3] {
97
97
 
                        case x: Int => 
98
98
 
                            x
99
99
 
                        case _ => 
100
100
 
                            throw("cannot parse parameters")
101
101
 
                    }
102
102
 
                    let period =                     match onboardingParameters[2] {
103
103
 
                        case x: Int => 
104
104
 
                            x
105
105
 
                        case _ => 
106
106
 
                            throw("cannot parse parameters")
107
107
 
                    }
108
108
 
                    let amountToBuyback = if ((assetIdStr != parentLpIdStr))
109
109
 
                        then fraction(amount, buybackRatio, 10000)
110
110
 
                        else 0
111
111
 
                    let amountToIssue = (amount - amountToBuyback)
112
112
 
                    let assetPriceToPluto = if ((assetIdStr != parentLpIdStr))
113
113
 
                        then calculatePoolPrice(poolAddress, assetIdStr)
114
114
 
                        else {
115
115
 
                            let parentLpPrice =                             match invoke(parametersAddress, "getParentLpPrice", [false, true], nil) {
116
116
 
                                case in: Int => 
117
117
 
                                    in
118
118
 
                                case _ => 
119
119
 
                                    throw("cannot load parent lp price")
120
120
 
                            }
121
121
 
                            if ((parentLpPrice == parentLpPrice))
122
122
 
                                then parentLpPrice
123
123
 
                                else throw("Strict value is not equal to itself.")
124
124
 
                            }
125
-
                    let inv = if ((assetIdStr == parentLpIdStr))
126
-
                        then unit
127
-
                        else if (evaluation)
128
-
                            then calcSwap(assetIdStr, amountToBuyback)
129
-
                            else invoke(poolAddress, "swap", [plutoIdStr, 0], [AttachedPayment(assetId, amountToBuyback)])
130
-
                    if ((inv == inv))
125
+
                    if ((assetPriceToPluto == assetPriceToPluto))
131
126
 
                        then {
132
-
                            let plutoBought =                             match inv {
133
-
                                case x: Int => 
134
-
                                    x
135
-
                                case _ => 
136
-
                                    0
137
-
                            }
138
-
                            let plutoIssued = fraction(amountToIssue, assetPriceToPluto, Scale8)
139
-
                            let totalPluto = (plutoBought + plutoIssued)
140
-
                            let premiumPlutoIssued = fraction(totalPluto, premium, 10000)
141
-
                            let teamPlutoIssued = fraction(totalPluto, teamPremium, 10000)
142
-
                            let inv2 = invoke(issuerAddress, "requestIssue", [((plutoIssued + premiumPlutoIssued) + teamPlutoIssued)], nil)
143
-
                            if ((inv2 == inv2))
144
-
                                then [plutoIssued, plutoBought, premiumPlutoIssued, teamPlutoIssued, amountToIssue, premium, period]
127
+
                            let inv = if ((assetIdStr == parentLpIdStr))
128
+
                                then unit
129
+
                                else if (evaluation)
130
+
                                    then calcSwap(assetIdStr, amountToBuyback)
131
+
                                    else invoke(poolAddress, "swap", [plutoIdStr, 0], [AttachedPayment(assetId, amountToBuyback)])
132
+
                            if ((inv == inv))
133
+
                                then {
134
+
                                    let plutoBought =                                     match inv {
135
+
                                        case x: Int => 
136
+
                                            x
137
+
                                        case _ => 
138
+
                                            0
139
+
                                    }
140
+
                                    let plutoIssued = fraction(amountToIssue, assetPriceToPluto, Scale8)
141
+
                                    let totalPluto = (plutoBought + plutoIssued)
142
+
                                    let premiumPlutoIssued = fraction(totalPluto, premium, 10000)
143
+
                                    let teamPlutoIssued = fraction(totalPluto, teamPremium, 10000)
144
+
                                    let inv2 = invoke(issuerAddress, "requestIssue", [((plutoIssued + premiumPlutoIssued) + teamPlutoIssued)], nil)
145
+
                                    if ((inv2 == inv2))
146
+
                                        then [plutoIssued, plutoBought, premiumPlutoIssued, teamPlutoIssued, amountToIssue, premium, period]
147
+
                                        else throw("Strict value is not equal to itself.")
148
+
                                    }
145
149
 
                                else throw("Strict value is not equal to itself.")
146
150
 
                            }
147
151
 
                        else throw("Strict value is not equal to itself.")
148
152
 
                    }
149
153
 
                else throw("Strict value is not equal to itself.")
150
154
 
            }
151
155
 
    }
152
156
 
153
157
 
154
158
 
@Callable(i)
155
159
 
func issuePluto (debug) = {
156
160
 
    let assetId = value(i.payments[0].assetId)
157
161
 
    let result = calculateIssuePluto(assetId, value(i.payments[0].amount), false)
158
162
 
    if ((result == result))
159
163
 
        then {
160
164
 
            let lockup = invoke(stakingAddress, "startOnboarding", [toString(i.caller), (result[0] + result[1]), result[2], result[6], result[5], toBase58String(value(i.payments[0].assetId))], [AttachedPayment(plutoId, ((result[0] + result[1]) + result[2]))])
161
165
 
            if ((lockup == lockup))
162
166
 
                then if (debug)
163
167
 
                    then throw(((((((("issued: " + toString(result[0])) + "; bought: ") + toString(result[1])) + "; premium: ") + toString(result[2])) + "; team: ") + toString(result[3])))
164
168
 
                    else [ScriptTransfer(treasuryAddress, result[4], assetId), ScriptTransfer(teamAddress, result[3], plutoId)]
165
169
 
                else throw("Strict value is not equal to itself.")
166
170
 
            }
167
171
 
        else throw("Strict value is not equal to itself.")
168
172
 
    }
169
173
 
170
174
 
171
175
 
172
176
 
@Callable(i)
173
177
 
func evaluateIssuePluto (debug,assetIdStr,amount) = {
174
178
 
    let assetId = fromBase58String(assetIdStr)
175
179
 
    let result = calculateIssuePluto(assetId, amount, true)
176
180
 
    if ((result == result))
177
181
 
        then if (debug)
178
182
 
            then throw(((((((("issued: " + toString(result[0])) + "; bought: ") + toString(result[1])) + "; premium: ") + toString(result[2])) + "; team: ") + toString(result[3])))
179
183
 
            else $Tuple2(nil, (result[0] + result[1]))
180
184
 
        else throw("Strict value is not equal to itself.")
181
185
 
    }
182
186
 
183
187
 
184
188
 
@Verifier(tx)
185
189
 
func verify () = sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
186
190
 

github/deemru/w8io/786bc32 
39.89 ms ◑