tx · ATWBUALNB8NX7CB4WWbq32im7GoaRPNNJPrsrXm78aHG

3NCWFHDzdPHZC6636ZkMLNDup9mjpbTLs7h:  -0.01000000 Waves

2023.04.04 10:19 [2519519] smart account 3NCWFHDzdPHZC6636ZkMLNDup9mjpbTLs7h > SELF 0.00000000 Waves

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

View: original | compacted
Prev: EVWMpF8k1zCAFsSpYSVSPX5GeCi5n3UCiBeuc62qepDN
Next: 8RskADFKd1rom1ZhBPsKSy7n9YFc7cwcJZ3eDwcEtnbE

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

github/deemru/w8io/026f985 
51.25 ms ◑