tx · EVWMpF8k1zCAFsSpYSVSPX5GeCi5n3UCiBeuc62qepDN

3NCWFHDzdPHZC6636ZkMLNDup9mjpbTLs7h:  -0.01000000 Waves

2023.04.04 10:13 [2519514] smart account 3NCWFHDzdPHZC6636ZkMLNDup9mjpbTLs7h > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "EVWMpF8k1zCAFsSpYSVSPX5GeCi5n3UCiBeuc62qepDN",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1680592458949,
    "version": 2,
    "chainId": 84,
    "sender": "3NCWFHDzdPHZC6636ZkMLNDup9mjpbTLs7h",
    "senderPublicKey": "3z8Q6Zu3KppVmn6fJJvrLc1Wo3krVHSvfaNcerm82md2",
    "proofs": [
        "LvJnfqzvhA9v7vEaLMLsP29Lr3bkug4AnmJ5U6o8m3E3559Ckj6toNz9ifoxUDm3XuVPzuhyQpMboTXYZ9WPMTL"
    ],
    "script": "base64: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",
    "height": 2519514,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: GctJ3TsQsEVdWkAXm937qNffDjiqwhJPuXKd1N9vyGes
Next: ATWBUALNB8NX7CB4WWbq32im7GoaRPNNJPrsrXm78aHG

Diff: 
Old
New
Differences
26
26
 
27
27
 
28
28
 
func throwError (errorMsg) = throw(((contractFile + ": ") + errorMsg))
29
+
30
+
31
+
func parseAssetId (input) = if ((input == "WAVES"))
32
+
    then unit
33
+
    else fromBase58String(input)
29
34
 
30
35
 
31
36
 
func getRate (proxy) = {
69
74
 
                                            case receivedStakingAsset: Int => 
70
75
 
                                                let newInternalAdditionalBalance = (currentInternalAdditionalBalance + amount)
71
76
 
                                                let newStakingAssetBalance = (currentStakingAssetBalance + receivedStakingAsset)
72
-
                                                let additionalBalance = (newInternalAdditionalBalance - newStakingAssetBalance)
77
+
                                                let additionalBalance = (newInternalAdditionalBalance - getStakingAssetBalance(assetId))
73
78
 
[IntegerEntry(keyInternalAdditionalBalance(assetId), newInternalAdditionalBalance), IntegerEntry(keyStakingAssetBalance(stakingAssetId), newStakingAssetBalance), IntegerEntry(keyAdditionalBalance(assetId), additionalBalance)]
74
79
 
                                            case _ => 
75
80
 
                                                nil
86
91
 
    }
87
92
 
88
93
 
89
-
func withdraw (assetId,amount,stakingAssetId,proxy,proxyRateMul) = {
94
+
func withdraw (assetId,amount,stakingAssetId,proxy,proxyRateMul,profitAddress) = {
90
95
 
    let currentAdditionalBalance = getAdditionalBalance(assetId)
91
96
 
    if ((currentAdditionalBalance == currentAdditionalBalance))
92
97
 
        then {
96
101
 
                    let currentProxyRate = getRate(proxy)
97
102
 
                    if ((currentProxyRate == currentProxyRate))
98
103
 
                        then {
104
+
                            let oldRate = fraction(proxyRateMul, currentAdditionalBalance, currentStakingAssetBalance)
105
+
                            let stakingAsset = parseAssetId(stakingAssetId)
106
+
                            let oldSendStakingAmount = fraction(proxyRateMul, amount, oldRate)
99
107
 
                            let sendStakingAssetAmount = fraction(proxyRateMul, amount, currentProxyRate)
108
+
                            let profitAmount = max([0, (oldSendStakingAmount - sendStakingAssetAmount)])
100
109
 
                            if ((sendStakingAssetAmount > 0))
101
110
 
                                then {
102
-
                                    let withdrawInvoke = invoke(proxy, "withdraw", nil, [AttachedPayment(fromBase58String(stakingAssetId), sendStakingAssetAmount)])
111
+
                                    let withdrawInvoke = invoke(proxy, "withdraw", nil, [AttachedPayment(stakingAsset, sendStakingAssetAmount)])
103
112
 
                                    if ((withdrawInvoke == withdrawInvoke))
104
113
 
                                        then                                         match withdrawInvoke {
105
114
 
                                            case receivedAssets: Int => 
106
115
 
                                                let newAdditionalBalance = (currentAdditionalBalance - receivedAssets)
107
-
                                                let newSWavesBalance = (currentStakingAssetBalance - sendStakingAssetAmount)
108
-
[IntegerEntry(keyAdditionalBalance(assetId), newAdditionalBalance), IntegerEntry(keyStakingAssetBalance(stakingAssetId), newSWavesBalance)]
116
+
                                                let newStakingAssetBalance = ((currentStakingAssetBalance - sendStakingAssetAmount) - profitAmount)
117
+
[IntegerEntry(keyAdditionalBalance(assetId), newAdditionalBalance), IntegerEntry(keyStakingAssetBalance(stakingAssetId), newStakingAssetBalance)]
109
118
 
                                            case _ => 
110
119
 
                                                nil
111
120
 
                                        }
121
130
 
    }
122
131
 
123
132
 
124
-
func rebalanceInternal (targetRatio,assetId,stakingAssetId,minBalance,proxy,proxyRateMul) = {
133
+
func rebalanceInternal (targetRatio,assetId,stakingAssetId,minBalance,proxy,proxyRateMul,profitAddress) = {
125
134
 
    let currentAdditionalBalance = getAdditionalBalance(assetId)
126
135
 
    if ((currentAdditionalBalance == currentAdditionalBalance))
127
136
 
        then {
145
154
 
                                        }
146
155
 
                                    else {
147
156
 
                                        let getAssetAmount = diff
148
-
                                        withdraw(assetId, getAssetAmount, stakingAssetId, proxy, proxyRateMul)
157
+
                                        withdraw(assetId, getAssetAmount, stakingAssetId, proxy, proxyRateMul, profitAddress)
149
158
 
                                        }
150
159
 
                            }
151
160
 
                        else throw("Strict value is not equal to itself.")
158
167
 
159
168
 
func rebalanceAsset (assetId) = match getLeaseProxyConfig(assetId) {
160
169
 
    case a: (Boolean, Int, Int, String, String, Int, String) => 
161
-
        let $t048894998 = a
162
-
        let isLeasable = $t048894998._1
163
-
        let leasedRatio = $t048894998._2
164
-
        let minBalance = $t048894998._3
165
-
        let proxyAddress = $t048894998._4
166
-
        let proxyAssetId = $t048894998._5
167
-
        let proxyRateMul = $t048894998._6
168
-
        let stakingProfitAddress = $t048894998._7
170
+
        let $t052565365 = a
171
+
        let isLeasable = $t052565365._1
172
+
        let leasedRatio = $t052565365._2
173
+
        let minBalance = $t052565365._3
174
+
        let proxyAddress = $t052565365._4
175
+
        let proxyAssetId = $t052565365._5
176
+
        let proxyRateMul = $t052565365._6
177
+
        let stakingProfitAddress = $t052565365._7
169
178
 
        if (isLeasable)
170
-
            then rebalanceInternal(leasedRatio, assetId, proxyAssetId, minBalance, addressFromStringValue(proxyAddress), proxyRateMul)
179
+
            then rebalanceInternal(leasedRatio, assetId, proxyAssetId, minBalance, addressFromStringValue(proxyAddress), proxyRateMul, addressFromStringValue(stakingProfitAddress))
180
+
            else nil
181
+
    case _ => 
182
+
        throwError((("[" + assetId) + "] Rebalance error"))
183
+
}
184
+
185
+
186
+
func rebalanceAsset2 (assetId,ratio) = match getLeaseProxyConfig(assetId) {
187
+
    case a: (Boolean, Int, Int, String, String, Int, String) => 
188
+
        let $t058415950 = a
189
+
        let isLeasable = $t058415950._1
190
+
        let leasedRatio = $t058415950._2
191
+
        let minBalance = $t058415950._3
192
+
        let proxyAddress = $t058415950._4
193
+
        let proxyAssetId = $t058415950._5
194
+
        let proxyRateMul = $t058415950._6
195
+
        let stakingProfitAddress = $t058415950._7
196
+
        if (isLeasable)
197
+
            then rebalanceInternal(ratio, assetId, proxyAssetId, minBalance, addressFromStringValue(proxyAddress), proxyRateMul, addressFromStringValue(stakingProfitAddress))
171
198
 
            else nil
172
199
 
    case _ => 
173
200
 
        throwError((("[" + assetId) + "] Rebalance error"))
178
205
 
func rebalance () = rebalanceAsset("WAVES")
179
206
 
180
207
 
208
+
209
+
@Callable(i)
210
+
func rebalance2 (ratio) = rebalanceAsset2("WAVES", ratio)
211
+
212
+

Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 6 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
let SEP = "__"
5
5
 
6
6
 
let contractFile = "rebalance.ride"
7
7
 
8
8
 
let keyFactoryAddress = "%s__factory"
9
9
 
10
10
 
func keyAdditionalBalance (assetId) = makeString(["%s%s", "additionalBalance", assetId], SEP)
11
11
 
12
12
 
13
13
 
func keyInternalAdditionalBalance (assetId) = makeString(["%s%s", "internalAdditionalBalance", assetId], SEP)
14
14
 
15
15
 
16
16
 
func keyStakingAssetBalance (assetId) = makeString(["%s%s", "stakingAssetBalance", assetId], SEP)
17
17
 
18
18
 
19
19
 
func getAdditionalBalance (assetId) = valueOrElse(getInteger(this, keyAdditionalBalance(assetId)), 0)
20
20
 
21
21
 
22
22
 
func getInternalAdditionalBalance (assetId) = valueOrElse(getInteger(this, keyInternalAdditionalBalance(assetId)), 0)
23
23
 
24
24
 
25
25
 
func getStakingAssetBalance (assetId) = valueOrElse(getInteger(this, keyStakingAssetBalance(assetId)), 0)
26
26
 
27
27
 
28
28
 
func throwError (errorMsg) = throw(((contractFile + ": ") + errorMsg))
29
+
30
+
31
+
func parseAssetId (input) = if ((input == "WAVES"))
32
+
    then unit
33
+
    else fromBase58String(input)
29
34
 
30
35
 
31
36
 
func getRate (proxy) = {
32
37
 
    let inv = invoke(proxy, "getRate", nil, nil)
33
38
 
    if ((inv == inv))
34
39
 
        then         match inv {
35
40
 
            case s: String => 
36
41
 
                parseIntValue(s)
37
42
 
            case _ => 
38
43
 
                throwError("getRate() returned zero")
39
44
 
        }
40
45
 
        else throw("Strict value is not equal to itself.")
41
46
 
    }
42
47
 
43
48
 
44
49
 
func getLeaseProxyConfig (assetId) = {
45
50
 
    let factory = addressFromStringValue(valueOrElse(getString(keyFactoryAddress), ""))
46
51
 
    let myAddressString = toString(this)
47
52
 
    invoke(factory, "getPoolLeaseConfigREADONLY", [myAddressString, assetId], nil)
48
53
 
    }
49
54
 
50
55
 
51
56
 
func deposit (assetId,amount,stakingAssetId,proxy) = {
52
57
 
    let currentAdditionalBalance = getAdditionalBalance(assetId)
53
58
 
    if ((currentAdditionalBalance == currentAdditionalBalance))
54
59
 
        then {
55
60
 
            let currentInternalAdditionalBalance = getInternalAdditionalBalance(assetId)
56
61
 
            if ((currentInternalAdditionalBalance == currentInternalAdditionalBalance))
57
62
 
                then {
58
63
 
                    let currentStakingAssetBalance = getStakingAssetBalance(stakingAssetId)
59
64
 
                    if ((currentStakingAssetBalance == currentStakingAssetBalance))
60
65
 
                        then {
61
66
 
                            let asset = if ((assetId == "WAVES"))
62
67
 
                                then unit
63
68
 
                                else fromBase58String(assetId)
64
69
 
                            if ((amount > 0))
65
70
 
                                then {
66
71
 
                                    let depositInvoke = invoke(proxy, "deposit", nil, [AttachedPayment(asset, amount)])
67
72
 
                                    if ((depositInvoke == depositInvoke))
68
73
 
                                        then                                         match depositInvoke {
69
74
 
                                            case receivedStakingAsset: Int => 
70
75
 
                                                let newInternalAdditionalBalance = (currentInternalAdditionalBalance + amount)
71
76
 
                                                let newStakingAssetBalance = (currentStakingAssetBalance + receivedStakingAsset)
72
-
                                                let additionalBalance = (newInternalAdditionalBalance - newStakingAssetBalance)
77
+
                                                let additionalBalance = (newInternalAdditionalBalance - getStakingAssetBalance(assetId))
73
78
 
[IntegerEntry(keyInternalAdditionalBalance(assetId), newInternalAdditionalBalance), IntegerEntry(keyStakingAssetBalance(stakingAssetId), newStakingAssetBalance), IntegerEntry(keyAdditionalBalance(assetId), additionalBalance)]
74
79
 
                                            case _ => 
75
80
 
                                                nil
76
81
 
                                        }
77
82
 
                                        else throw("Strict value is not equal to itself.")
78
83
 
                                    }
79
84
 
                                else nil
80
85
 
                            }
81
86
 
                        else throw("Strict value is not equal to itself.")
82
87
 
                    }
83
88
 
                else throw("Strict value is not equal to itself.")
84
89
 
            }
85
90
 
        else throw("Strict value is not equal to itself.")
86
91
 
    }
87
92
 
88
93
 
89
-
func withdraw (assetId,amount,stakingAssetId,proxy,proxyRateMul) = {
94
+
func withdraw (assetId,amount,stakingAssetId,proxy,proxyRateMul,profitAddress) = {
90
95
 
    let currentAdditionalBalance = getAdditionalBalance(assetId)
91
96
 
    if ((currentAdditionalBalance == currentAdditionalBalance))
92
97
 
        then {
93
98
 
            let currentStakingAssetBalance = getStakingAssetBalance(stakingAssetId)
94
99
 
            if ((currentStakingAssetBalance == currentStakingAssetBalance))
95
100
 
                then {
96
101
 
                    let currentProxyRate = getRate(proxy)
97
102
 
                    if ((currentProxyRate == currentProxyRate))
98
103
 
                        then {
104
+
                            let oldRate = fraction(proxyRateMul, currentAdditionalBalance, currentStakingAssetBalance)
105
+
                            let stakingAsset = parseAssetId(stakingAssetId)
106
+
                            let oldSendStakingAmount = fraction(proxyRateMul, amount, oldRate)
99
107
 
                            let sendStakingAssetAmount = fraction(proxyRateMul, amount, currentProxyRate)
108
+
                            let profitAmount = max([0, (oldSendStakingAmount - sendStakingAssetAmount)])
100
109
 
                            if ((sendStakingAssetAmount > 0))
101
110
 
                                then {
102
-
                                    let withdrawInvoke = invoke(proxy, "withdraw", nil, [AttachedPayment(fromBase58String(stakingAssetId), sendStakingAssetAmount)])
111
+
                                    let withdrawInvoke = invoke(proxy, "withdraw", nil, [AttachedPayment(stakingAsset, sendStakingAssetAmount)])
103
112
 
                                    if ((withdrawInvoke == withdrawInvoke))
104
113
 
                                        then                                         match withdrawInvoke {
105
114
 
                                            case receivedAssets: Int => 
106
115
 
                                                let newAdditionalBalance = (currentAdditionalBalance - receivedAssets)
107
-
                                                let newSWavesBalance = (currentStakingAssetBalance - sendStakingAssetAmount)
108
-
[IntegerEntry(keyAdditionalBalance(assetId), newAdditionalBalance), IntegerEntry(keyStakingAssetBalance(stakingAssetId), newSWavesBalance)]
116
+
                                                let newStakingAssetBalance = ((currentStakingAssetBalance - sendStakingAssetAmount) - profitAmount)
117
+
[IntegerEntry(keyAdditionalBalance(assetId), newAdditionalBalance), IntegerEntry(keyStakingAssetBalance(stakingAssetId), newStakingAssetBalance)]
109
118
 
                                            case _ => 
110
119
 
                                                nil
111
120
 
                                        }
112
121
 
                                        else throw("Strict value is not equal to itself.")
113
122
 
                                    }
114
123
 
                                else nil
115
124
 
                            }
116
125
 
                        else throw("Strict value is not equal to itself.")
117
126
 
                    }
118
127
 
                else throw("Strict value is not equal to itself.")
119
128
 
            }
120
129
 
        else throw("Strict value is not equal to itself.")
121
130
 
    }
122
131
 
123
132
 
124
-
func rebalanceInternal (targetRatio,assetId,stakingAssetId,minBalance,proxy,proxyRateMul) = {
133
+
func rebalanceInternal (targetRatio,assetId,stakingAssetId,minBalance,proxy,proxyRateMul,profitAddress) = {
125
134
 
    let currentAdditionalBalance = getAdditionalBalance(assetId)
126
135
 
    if ((currentAdditionalBalance == currentAdditionalBalance))
127
136
 
        then {
128
137
 
            let currentStakingAssetBalance = getStakingAssetBalance(stakingAssetId)
129
138
 
            if ((currentStakingAssetBalance == currentStakingAssetBalance))
130
139
 
                then {
131
140
 
                    let availableBalance = if ((assetId == "WAVES"))
132
141
 
                        then wavesBalance(this).available
133
142
 
                        else assetBalance(this, fromBase58String(assetId))
134
143
 
                    if ((availableBalance == availableBalance))
135
144
 
                        then {
136
145
 
                            let wholeBalance = max([0, ((availableBalance + currentAdditionalBalance) - minBalance)])
137
146
 
                            let targetAdditionalBalance = fraction(targetRatio, wholeBalance, 100)
138
147
 
                            let diff = (currentAdditionalBalance - targetAdditionalBalance)
139
148
 
                            if ((diff == 0))
140
149
 
                                then nil
141
150
 
                                else if ((0 > diff))
142
151
 
                                    then {
143
152
 
                                        let sendAssetAmount = -(diff)
144
153
 
                                        deposit(assetId, sendAssetAmount, stakingAssetId, proxy)
145
154
 
                                        }
146
155
 
                                    else {
147
156
 
                                        let getAssetAmount = diff
148
-
                                        withdraw(assetId, getAssetAmount, stakingAssetId, proxy, proxyRateMul)
157
+
                                        withdraw(assetId, getAssetAmount, stakingAssetId, proxy, proxyRateMul, profitAddress)
149
158
 
                                        }
150
159
 
                            }
151
160
 
                        else throw("Strict value is not equal to itself.")
152
161
 
                    }
153
162
 
                else throw("Strict value is not equal to itself.")
154
163
 
            }
155
164
 
        else throw("Strict value is not equal to itself.")
156
165
 
    }
157
166
 
158
167
 
159
168
 
func rebalanceAsset (assetId) = match getLeaseProxyConfig(assetId) {
160
169
 
    case a: (Boolean, Int, Int, String, String, Int, String) => 
161
-
        let $t048894998 = a
162
-
        let isLeasable = $t048894998._1
163
-
        let leasedRatio = $t048894998._2
164
-
        let minBalance = $t048894998._3
165
-
        let proxyAddress = $t048894998._4
166
-
        let proxyAssetId = $t048894998._5
167
-
        let proxyRateMul = $t048894998._6
168
-
        let stakingProfitAddress = $t048894998._7
170
+
        let $t052565365 = a
171
+
        let isLeasable = $t052565365._1
172
+
        let leasedRatio = $t052565365._2
173
+
        let minBalance = $t052565365._3
174
+
        let proxyAddress = $t052565365._4
175
+
        let proxyAssetId = $t052565365._5
176
+
        let proxyRateMul = $t052565365._6
177
+
        let stakingProfitAddress = $t052565365._7
169
178
 
        if (isLeasable)
170
-
            then rebalanceInternal(leasedRatio, assetId, proxyAssetId, minBalance, addressFromStringValue(proxyAddress), proxyRateMul)
179
+
            then rebalanceInternal(leasedRatio, assetId, proxyAssetId, minBalance, addressFromStringValue(proxyAddress), proxyRateMul, addressFromStringValue(stakingProfitAddress))
180
+
            else nil
181
+
    case _ => 
182
+
        throwError((("[" + assetId) + "] Rebalance error"))
183
+
}
184
+
185
+
186
+
func rebalanceAsset2 (assetId,ratio) = match getLeaseProxyConfig(assetId) {
187
+
    case a: (Boolean, Int, Int, String, String, Int, String) => 
188
+
        let $t058415950 = a
189
+
        let isLeasable = $t058415950._1
190
+
        let leasedRatio = $t058415950._2
191
+
        let minBalance = $t058415950._3
192
+
        let proxyAddress = $t058415950._4
193
+
        let proxyAssetId = $t058415950._5
194
+
        let proxyRateMul = $t058415950._6
195
+
        let stakingProfitAddress = $t058415950._7
196
+
        if (isLeasable)
197
+
            then rebalanceInternal(ratio, assetId, proxyAssetId, minBalance, addressFromStringValue(proxyAddress), proxyRateMul, addressFromStringValue(stakingProfitAddress))
171
198
 
            else nil
172
199
 
    case _ => 
173
200
 
        throwError((("[" + assetId) + "] Rebalance error"))
174
201
 
}
175
202
 
176
203
 
177
204
 
@Callable(i)
178
205
 
func rebalance () = rebalanceAsset("WAVES")
179
206
 
180
207
 
208
+
209
+
@Callable(i)
210
+
func rebalance2 (ratio) = rebalanceAsset2("WAVES", ratio)
211
+
212
+

github/deemru/w8io/169f3d6 
116.14 ms ◑