2020.11.24 19:04 [2343442] smart account 3PHCVBNW4mJngUZ7vBECrYGpxR978RqUNxk > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "6RRgGuciVviixWbEeCqf4ehtkoDsoRKj9YHc2ExVdVen",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1606233913704,
    "version": 2,
    "chainId": 87,
    "sender": "3PHCVBNW4mJngUZ7vBECrYGpxR978RqUNxk",
    "senderPublicKey": "J3kJtPfR4reGdz7U3guodULaXB8iHpzEQa2VaR9FpuiW",
    "proofs": [
        "55aAfvfxY7grkGvL3FESnmKjd4LHnNeS2M1pYoy2nzCoU84sVjpnPhwU661DCY1nEqTnLDoPHoH9hfcEvq1VeRxn"
    ],
    "script": "base64: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",
    "height": 2343442,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: CCodKP9uP27tXHWYx59te4e3sEkunhmbhZJUCYWEAwax
Next: 4AUN4tGgXbExA5tqfVFXXWC3oKKWyovAiSnQV2qWJi9T

Diff: 
Old
New
Differences
298
298
 
                                let governanceReward = $t01288012971._3
299
299
 
                                let newAmountTokenA = ((balanceA - amountWithFee) - governanceReward)
300
300
 
                                let newAmountTokenB = (balanceB + pmtAmount)
301
-
                                if (if (if ((assetIdA == USDN))
302
-
                                    then (stakedAmountUSDN > newAmountTokenA)
303
-
                                    else false)
304
-
                                    then true
305
-
                                    else if ((assetIdB == USDN))
306
-
                                        then (stakedAmountUSDN > newAmountTokenB)
307
-
                                        else false)
308
-
                                    then throwInsufficientAvailableBalance(amountWithFee, availableBalanceA, assetNameA)
309
-
                                    else [IntegerEntry(keyBalanceA, newAmountTokenA), IntegerEntry(keyBalanceB, newAmountTokenB), ScriptTransfer(i.caller, amountWithFee, assetIdSend), ScriptTransfer(governanceAddress, governanceReward, assetIdSend)]
301
+
                                if (true)
302
+
                                    then throw(((toString(newAmountTokenA) + " ") + toString(availableBalanceA)))
303
+
                                    else if (if ((availableBalanceA > newAmountTokenA))
304
+
                                        then true
305
+
                                        else (availableBalanceB > newAmountTokenB))
306
+
                                        then throwInsufficientAvailableBalance(amountWithFee, availableBalanceA, assetNameA)
307
+
                                        else [IntegerEntry(keyBalanceA, newAmountTokenA), IntegerEntry(keyBalanceB, newAmountTokenB), ScriptTransfer(i.caller, amountWithFee, assetIdSend), ScriptTransfer(governanceAddress, governanceReward, assetIdSend)]
310
308
 
                                }
311
309
 
                            else throw(((("Incorrect asset attached. Expected: " + strAssetIdA) + " or ") + strAssetIdB))
312
310
 
    }
Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 4 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
let version = "1.0.0"
5
5
 
6
6
 
let keyVersion = "version"
7
7
 
8
8
 
let keyActive = "active"
9
9
 
10
10
 
let keyAssetIdA = "A_asset_id"
11
11
 
12
12
 
let keyAssetIdB = "B_asset_id"
13
13
 
14
14
 
let keyBalanceA = "A_asset_balance"
15
15
 
16
16
 
let keyBalanceB = "B_asset_balance"
17
17
 
18
18
 
let keyShareAssetId = "share_asset_id"
19
19
 
20
20
 
let keyShareAssetSupply = "share_asset_supply"
21
21
 
22
22
 
let keyCommission = "commission"
23
23
 
24
24
 
let keyCommissionScaleDelimiter = "commission_scale_delimiter"
25
25
 
26
26
 
let keyCause = "shutdown_cause"
27
27
 
28
28
 
let adminPubKey1 = base58'DXDY2itiEcYBtGkVLnkpHtDFyWQUkoLJz79uJ7ECbMrA'
29
29
 
30
30
 
let adminPubKey2 = base58'E6Wa1SGoktYcjHjsKrvjMiqJY3SWmGKcD8Q5L8kxSPS7'
31
31
 
32
32
 
let adminPubKey3 = base58'AZmWJtuy4GeVrMmJH4hfFBRApe1StvhJSk4jcbT6bArQ'
33
33
 
34
34
 
let adminPubKey4startStop = base58'EtVkT6ed8GtbUiVVEqdmEqsp2J4qbb3rre2HFgxeVYdg'
35
35
 
36
36
 
let governanceAddress = Address(base58'3PKnuKdJbtXZ3nn9W4zgeMftrf53MbQBZw7')
37
37
 
38
38
 
let stakingAddress = Address(base58'3PNikM6yp4NqcSU8guxQtmR5onr2D4e8yTJ')
39
39
 
40
40
 
let USDN = base58'DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p'
41
41
 
42
42
 
let stakingFeeInUSDN = (9 * value(value(assetInfo(USDN)).minSponsoredFee))
43
43
 
44
44
 
let isActive = getBooleanValue(this, keyActive)
45
45
 
46
46
 
let strAssetIdA = getStringValue(this, keyAssetIdA)
47
47
 
48
48
 
let strAssetIdB = getStringValue(this, keyAssetIdB)
49
49
 
50
50
 
let assetIdA = if ((strAssetIdA == "WAVES"))
51
51
 
    then unit
52
52
 
    else fromBase58String(strAssetIdA)
53
53
 
54
54
 
let assetIdB = if ((strAssetIdB == "WAVES"))
55
55
 
    then unit
56
56
 
    else fromBase58String(strAssetIdB)
57
57
 
58
58
 
let assetNameA = match assetIdA {
59
59
 
    case id: ByteVector => 
60
60
 
        value(assetInfo(id)).name
61
61
 
    case waves: Unit => 
62
62
 
        "WAVES"
63
63
 
    case _ => 
64
64
 
        throw("Match error")
65
65
 
}
66
66
 
67
67
 
let assetNameB = match assetIdB {
68
68
 
    case id: ByteVector => 
69
69
 
        value(assetInfo(id)).name
70
70
 
    case waves: Unit => 
71
71
 
        "WAVES"
72
72
 
    case _ => 
73
73
 
        throw("Match error")
74
74
 
}
75
75
 
76
76
 
let balanceA = getIntegerValue(this, keyBalanceA)
77
77
 
78
78
 
let balanceB = getIntegerValue(this, keyBalanceB)
79
79
 
80
80
 
let shareAssetId = fromBase58String(getStringValue(this, keyShareAssetId))
81
81
 
82
82
 
let shareAssetSupply = getIntegerValue(this, keyShareAssetSupply)
83
83
 
84
84
 
let commission = 3000
85
85
 
86
86
 
let commissionGovernance = 1200
87
87
 
88
88
 
let commissionScaleDelimiter = 1000000
89
89
 
90
90
 
let scaleValue3 = 1000
91
91
 
92
92
 
let scaleValue8 = 100000000
93
93
 
94
94
 
let slippageToleranceDelimiter = 1000
95
95
 
96
96
 
let scaleValue8Digits = 8
97
97
 
98
98
 
func accountBalance (assetId) = match assetId {
99
99
 
    case id: ByteVector => 
100
100
 
        assetBalance(this, id)
101
101
 
    case waves: Unit => 
102
102
 
        wavesBalance(this).available
103
103
 
    case _ => 
104
104
 
        throw("Match error")
105
105
 
}
106
106
 
107
107
 
108
108
 
let stakedAmountUSDN = match getInteger(stakingAddress, ((("rpd_balance_" + toBase58String(USDN)) + "_") + toString(this))) {
109
109
 
    case staked: Int => 
110
110
 
        staked
111
111
 
    case nothing: Unit => 
112
112
 
        0
113
113
 
    case _ => 
114
114
 
        throw("Match error")
115
115
 
}
116
116
 
117
117
 
let availableBalanceA = (balanceA - (if ((assetIdA == USDN))
118
118
 
    then stakedAmountUSDN
119
119
 
    else 0))
120
120
 
121
121
 
let availableBalanceB = (balanceB - (if ((assetIdB == USDN))
122
122
 
    then stakedAmountUSDN
123
123
 
    else 0))
124
124
 
125
125
 
let accountBalanceWithStakedA = (accountBalance(assetIdA) + (if ((assetIdA == USDN))
126
126
 
    then stakedAmountUSDN
127
127
 
    else 0))
128
128
 
129
129
 
let accountBalanceWithStakedB = (accountBalance(assetIdB) + (if ((assetIdB == USDN))
130
130
 
    then stakedAmountUSDN
131
131
 
    else 0))
132
132
 
133
133
 
let hasEnoughBalance = if ((accountBalanceWithStakedA >= balanceA))
134
134
 
    then (accountBalanceWithStakedB >= balanceB)
135
135
 
    else false
136
136
 
137
137
 
func getAssetInfo (assetId) = match assetId {
138
138
 
    case id: ByteVector => 
139
139
 
        let stringId = toBase58String(id)
140
140
 
        let info = valueOrErrorMessage(assetInfo(id), (("Asset " + stringId) + " doesn't exist"))
141
141
 
        $Tuple3(stringId, info.name, info.decimals)
142
142
 
    case waves: Unit => 
143
143
 
        $Tuple3("WAVES", "WAVES", 8)
144
144
 
    case _ => 
145
145
 
        throw("Match error")
146
146
 
}
147
147
 
148
148
 
149
149
 
func suspend (cause) = [BooleanEntry(keyActive, false), StringEntry(keyCause, cause)]
150
150
 
151
151
 
152
152
 
func deductStakingFee (amount,assetId) = (amount - (if ((assetId == USDN))
153
153
 
    then stakingFeeInUSDN
154
154
 
    else 0))
155
155
 
156
156
 
157
157
 
func throwInsufficientAvailableBalance (amount,available,assetName) = throw((((((((("Insufficient DApp balance to pay " + toString(amount)) + " ") + assetName) + " due to staking. Available: ") + toString(available)) + " ") + assetName) + ". Please contact support in Telegram: https://t.me/swopfisupport"))
158
158
 
159
159
 
160
160
 
func throwInsufficientAvailableBalances (amountA,amountB) = throw((((((((((((((((("Not enough balance on DApp to pay " + toString(amountA)) + " ") + assetNameA) + " and ") + toString(amountB)) + " ") + assetNameB) + " at this moment. Available: ") + toString(availableBalanceA)) + " ") + assetNameA) + " and ") + toString(availableBalanceB)) + " ") + assetNameB) + ". Please contact support in Telegram: https://t.me/swopfisupport"))
161
161
 
162
162
 
163
163
 
@Callable(i)
164
164
 
func init () = {
165
165
 
    let $t044454522 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
166
166
 
    let pmtAmountA = $t044454522._1
167
167
 
    let pmtAssetIdA = $t044454522._2
168
168
 
    let $t045274604 = $Tuple2(i.payments[1].amount, i.payments[1].assetId)
169
169
 
    let pmtAmountB = $t045274604._1
170
170
 
    let pmtAssetIdB = $t045274604._2
171
171
 
    let $t046094686 = getAssetInfo(pmtAssetIdA)
172
172
 
    let pmtStrAssetIdA = $t046094686._1
173
173
 
    let pmtAssetNameA = $t046094686._2
174
174
 
    let pmtDecimalsA = $t046094686._3
175
175
 
    let $t046914768 = getAssetInfo(pmtAssetIdB)
176
176
 
    let pmtStrAssetIdB = $t046914768._1
177
177
 
    let pmtAssetNameB = $t046914768._2
178
178
 
    let pmtDecimalsB = $t046914768._3
179
179
 
    if (isDefined(getBoolean(this, keyActive)))
180
180
 
        then throw("DApp is already active")
181
181
 
        else if ((pmtAssetIdA == pmtAssetIdB))
182
182
 
            then throw("Assets must be different")
183
183
 
            else {
184
184
 
                let shareName = ((("s" + take(pmtAssetNameA, 7)) + "_") + take(pmtAssetNameB, 7))
185
185
 
                let shareDescription = ((((("ShareToken of SwopFi protocol for " + pmtAssetNameA) + " and ") + pmtAssetNameB) + " at address ") + toString(this))
186
186
 
                let shareDecimals = ((pmtDecimalsA + pmtDecimalsB) / 2)
187
187
 
                let shareInitialSupply = fraction(pow(pmtAmountA, pmtDecimalsA, 5, 1, pmtDecimalsA, HALFDOWN), pow(pmtAmountB, pmtDecimalsB, 5, 1, pmtDecimalsB, HALFDOWN), pow(10, 0, shareDecimals, 0, 0, HALFDOWN))
188
188
 
                let shareIssue = Issue(shareName, shareDescription, shareInitialSupply, shareDecimals, true)
189
189
 
                let shareIssueId = calculateAssetId(shareIssue)
190
190
 
[StringEntry(keyVersion, version), BooleanEntry(keyActive, true), StringEntry(keyAssetIdA, pmtStrAssetIdA), StringEntry(keyAssetIdB, pmtStrAssetIdB), IntegerEntry(keyBalanceA, pmtAmountA), IntegerEntry(keyBalanceB, pmtAmountB), IntegerEntry(keyCommission, commission), IntegerEntry(keyCommissionScaleDelimiter, commissionScaleDelimiter), shareIssue, StringEntry(keyShareAssetId, toBase58String(shareIssueId)), IntegerEntry(keyShareAssetSupply, shareInitialSupply), ScriptTransfer(i.caller, shareInitialSupply, shareIssueId)]
191
191
 
                }
192
192
 
    }
193
193
 
194
194
 
195
195
 
196
196
 
@Callable(i)
197
197
 
func replenishWithTwoTokens (slippageTolerance) = {
198
198
 
    let pmtAssetIdA = i.payments[0].assetId
199
199
 
    let pmtAssetIdB = i.payments[1].assetId
200
200
 
    let pmtAmountA = deductStakingFee(i.payments[0].amount, pmtAssetIdA)
201
201
 
    let pmtAmountB = deductStakingFee(i.payments[1].amount, pmtAssetIdB)
202
202
 
    let tokenRatio = fraction(fraction(balanceA, scaleValue8, pmtAmountA), scaleValue3, fraction(balanceB, scaleValue8, pmtAmountB))
203
203
 
    let ratioShareTokensInA = fraction(pmtAmountA, scaleValue8, balanceA)
204
204
 
    let ratioShareTokensInB = fraction(pmtAmountB, scaleValue8, balanceB)
205
205
 
    let shareTokenToPayAmount = fraction(min([ratioShareTokensInA, ratioShareTokensInB]), shareAssetSupply, scaleValue8)
206
206
 
    if (!(isActive))
207
207
 
        then throw("DApp is inactive at this moment")
208
208
 
        else if (if ((0 > slippageTolerance))
209
209
 
            then true
210
210
 
            else (slippageTolerance > slippageToleranceDelimiter))
211
211
 
            then throw(((("Slippage tolerance must be between 0 and " + toString(slippageToleranceDelimiter)) + " inclusively. Actual: ") + toString(slippageTolerance)))
212
212
 
            else if ((size(i.payments) != 2))
213
213
 
                then throw("Two attached assets expected")
214
214
 
                else if (if ((pmtAssetIdA != assetIdA))
215
215
 
                    then true
216
216
 
                    else (pmtAssetIdB != assetIdB))
217
217
 
                    then throw(((("Incorrect assets attached. Expected: " + strAssetIdA) + " and ") + strAssetIdB))
218
218
 
                    else if (if ((((scaleValue3 * (slippageToleranceDelimiter - slippageTolerance)) / slippageToleranceDelimiter) > tokenRatio))
219
219
 
                        then true
220
220
 
                        else (tokenRatio > ((scaleValue3 * (slippageToleranceDelimiter + slippageTolerance)) / slippageToleranceDelimiter)))
221
221
 
                        then throw("Incorrect assets amount: amounts must have the contract ratio")
222
222
 
                        else if ((shareTokenToPayAmount == 0))
223
223
 
                            then throw("Too small amount to replenish")
224
224
 
                            else if (!(hasEnoughBalance))
225
225
 
                                then suspend(((((((((((((((("Suspicious state. Actual balances: " + toString(balanceA)) + " ") + assetNameA) + ", ") + toString(balanceB)) + " ") + assetNameB) + ". State: ") + toString(accountBalance(assetIdA))) + " ") + assetNameA) + ", ") + toString(accountBalance(assetIdB))) + " ") + assetNameB))
226
226
 
                                else [IntegerEntry(keyBalanceA, (balanceA + pmtAmountA)), IntegerEntry(keyBalanceB, (balanceB + pmtAmountB)), IntegerEntry(keyShareAssetSupply, (shareAssetSupply + shareTokenToPayAmount)), Reissue(shareAssetId, shareTokenToPayAmount, true), ScriptTransfer(i.caller, shareTokenToPayAmount, shareAssetId)]
227
227
 
    }
228
228
 
229
229
 
230
230
 
231
231
 
@Callable(i)
232
232
 
func withdraw () = {
233
233
 
    let $t089629112 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
234
234
 
    let pmtAmount = $t089629112._1
235
235
 
    let pmtAssetId = $t089629112._2
236
236
 
    let amountToPayA = deductStakingFee(fraction(pmtAmount, balanceA, shareAssetSupply), assetIdA)
237
237
 
    let amountToPayB = deductStakingFee(fraction(pmtAmount, balanceB, shareAssetSupply), assetIdB)
238
238
 
    if (!(isActive))
239
239
 
        then throw("DApp is inactive at this moment")
240
240
 
        else if ((size(i.payments) != 1))
241
241
 
            then throw("One attached payment expected")
242
242
 
            else if ((pmtAssetId != shareAssetId))
243
243
 
                then throw(("Incorrect asset attached. Expected: " + toBase58String(shareAssetId)))
244
244
 
                else if (!(hasEnoughBalance))
245
245
 
                    then suspend(((((((((((((((("Suspicious state. Actual balances: " + toString(balanceA)) + " ") + assetNameA) + ", ") + toString(balanceB)) + " ") + assetNameB) + ". State: ") + toString(accountBalance(assetIdA))) + " ") + assetNameA) + ", ") + toString(accountBalance(assetIdB))) + " ") + assetNameB))
246
246
 
                    else if (if ((amountToPayA > availableBalanceA))
247
247
 
                        then true
248
248
 
                        else (amountToPayB > availableBalanceB))
249
249
 
                        then throwInsufficientAvailableBalances(amountToPayA, amountToPayB)
250
250
 
                        else [IntegerEntry(keyBalanceA, (balanceA - amountToPayA)), IntegerEntry(keyBalanceB, (balanceB - amountToPayB)), IntegerEntry(keyShareAssetSupply, (shareAssetSupply - pmtAmount)), Burn(shareAssetId, pmtAmount), ScriptTransfer(i.caller, amountToPayA, assetIdA), ScriptTransfer(i.caller, amountToPayB, assetIdB)]
251
251
 
    }
252
252
 
253
253
 
254
254
 
255
255
 
@Callable(i)
256
256
 
func exchange (minAmountToReceive) = {
257
257
 
    let $t01050210577 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
258
258
 
    let pmtAmount = $t01050210577._1
259
259
 
    let pmtAssetId = $t01050210577._2
260
260
 
    func calculateFees (tokenFrom,tokenTo) =     {
261
261
 
        let amountWithoutFee = fraction(tokenTo, pmtAmount, (pmtAmount + tokenFrom))
262
262
 
        let amountWithFee = fraction(amountWithoutFee, (commissionScaleDelimiter - commission), commissionScaleDelimiter)
263
263
 
        let governanceReward = fraction(amountWithoutFee, commissionGovernance, commissionScaleDelimiter)
264
264
 
        if ((minAmountToReceive > amountWithFee))
265
265
 
            then throw(((("Calculated amount to receive " + toString(amountWithFee)) + " is less than specified minimum ") + toString(minAmountToReceive)))
266
266
 
            else $Tuple3(amountWithoutFee, amountWithFee, governanceReward)
267
267
 
        }
268
268
 
269
269
 
    if (!(isActive))
270
270
 
        then throw("DApp is inactive at this moment")
271
271
 
        else if ((0 >= minAmountToReceive))
272
272
 
            then throw(("Minimal amount to receive must be positive. Actual: " + toString(minAmountToReceive)))
273
273
 
            else if ((size(i.payments) != 1))
274
274
 
                then throw("One attached payment expected")
275
275
 
                else if (!(hasEnoughBalance))
276
276
 
                    then suspend(((((((((((((((("Suspicious state. Actual balances: " + toString(balanceA)) + " ") + assetNameA) + ", ") + toString(balanceB)) + " ") + assetNameB) + ". State: ") + toString(accountBalance(assetIdA))) + " ") + assetNameA) + ", ") + toString(accountBalance(assetIdB))) + " ") + assetNameB))
277
277
 
                    else if ((pmtAssetId == assetIdA))
278
278
 
                        then {
279
279
 
                            let assetIdSend = assetIdB
280
280
 
                            let $t01193612027 = calculateFees(balanceA, balanceB)
281
281
 
                            let amountWithoutFee = $t01193612027._1
282
282
 
                            let amountWithFee = $t01193612027._2
283
283
 
                            let governanceReward = $t01193612027._3
284
284
 
                            let newAmountTokenA = (balanceA + pmtAmount)
285
285
 
                            let newAmountTokenB = ((balanceB - amountWithFee) - governanceReward)
286
286
 
                            if (if ((availableBalanceA > newAmountTokenA))
287
287
 
                                then true
288
288
 
                                else (availableBalanceB > newAmountTokenB))
289
289
 
                                then throwInsufficientAvailableBalance(amountWithFee, availableBalanceB, assetNameB)
290
290
 
                                else [IntegerEntry(keyBalanceA, newAmountTokenA), IntegerEntry(keyBalanceB, newAmountTokenB), ScriptTransfer(i.caller, amountWithFee, assetIdSend), ScriptTransfer(governanceAddress, governanceReward, assetIdSend)]
291
291
 
                            }
292
292
 
                        else if ((pmtAssetId == assetIdB))
293
293
 
                            then {
294
294
 
                                let assetIdSend = assetIdA
295
295
 
                                let $t01288012971 = calculateFees(balanceB, balanceA)
296
296
 
                                let amountWithoutFee = $t01288012971._1
297
297
 
                                let amountWithFee = $t01288012971._2
298
298
 
                                let governanceReward = $t01288012971._3
299
299
 
                                let newAmountTokenA = ((balanceA - amountWithFee) - governanceReward)
300
300
 
                                let newAmountTokenB = (balanceB + pmtAmount)
301
-
                                if (if (if ((assetIdA == USDN))
302
-
                                    then (stakedAmountUSDN > newAmountTokenA)
303
-
                                    else false)
304
-
                                    then true
305
-
                                    else if ((assetIdB == USDN))
306
-
                                        then (stakedAmountUSDN > newAmountTokenB)
307
-
                                        else false)
308
-
                                    then throwInsufficientAvailableBalance(amountWithFee, availableBalanceA, assetNameA)
309
-
                                    else [IntegerEntry(keyBalanceA, newAmountTokenA), IntegerEntry(keyBalanceB, newAmountTokenB), ScriptTransfer(i.caller, amountWithFee, assetIdSend), ScriptTransfer(governanceAddress, governanceReward, assetIdSend)]
301
+
                                if (true)
302
+
                                    then throw(((toString(newAmountTokenA) + " ") + toString(availableBalanceA)))
303
+
                                    else if (if ((availableBalanceA > newAmountTokenA))
304
+
                                        then true
305
+
                                        else (availableBalanceB > newAmountTokenB))
306
+
                                        then throwInsufficientAvailableBalance(amountWithFee, availableBalanceA, assetNameA)
307
+
                                        else [IntegerEntry(keyBalanceA, newAmountTokenA), IntegerEntry(keyBalanceB, newAmountTokenB), ScriptTransfer(i.caller, amountWithFee, assetIdSend), ScriptTransfer(governanceAddress, governanceReward, assetIdSend)]
310
308
 
                                }
311
309
 
                            else throw(((("Incorrect asset attached. Expected: " + strAssetIdA) + " or ") + strAssetIdB))
312
310
 
    }
313
311
 
314
312
 
315
313
 
316
314
 
@Callable(i)
317
315
 
func shutdown () = if (!(isActive))
318
316
 
    then throw(("DApp is already suspended. Cause: " + valueOrElse(getString(this, keyCause), "the cause wasn't specified")))
319
317
 
    else if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminPubKey4startStop], i.callerPublicKey)))
320
318
 
        then throw("Only admin can call this function")
321
319
 
        else suspend("Paused by admin")
322
320
 
323
321
 
324
322
 
325
323
 
@Callable(i)
326
324
 
func activate () = if (isActive)
327
325
 
    then throw("DApp is already active")
328
326
 
    else if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminPubKey4startStop], i.callerPublicKey)))
329
327
 
        then throw("Only admin can call this function")
330
328
 
        else [BooleanEntry(keyActive, true), DeleteEntry(keyCause)]
331
329
 
332
330
 
333
331
 
334
332
 
@Callable(i)
335
333
 
func takeIntoAccountExtraFunds (amountLeave) = {
336
334
 
    let uncountableAmountEnrollAssetA = (accountBalanceWithStakedA - balanceA)
337
335
 
    let uncountableAmountEnrollAssetB = (accountBalanceWithStakedB - balanceB)
338
336
 
    let amountEnrollA = (uncountableAmountEnrollAssetA - (if ((assetIdA == USDN))
339
337
 
        then amountLeave
340
338
 
        else 0))
341
339
 
    let amountEnrollB = (uncountableAmountEnrollAssetB - (if ((assetIdB == USDN))
342
340
 
        then amountLeave
343
341
 
        else 0))
344
342
 
    if (!(isActive))
345
343
 
        then throw("DApp is inactive at this moment")
346
344
 
        else if ((0 > amountLeave))
347
345
 
            then throw(("Argument 'amountLeave' cannot be negative. Actual: " + toString(amountLeave)))
348
346
 
            else if (if ((0 > uncountableAmountEnrollAssetA))
349
347
 
                then true
350
348
 
                else (0 > uncountableAmountEnrollAssetB))
351
349
 
                then suspend("Enroll amount negative")
352
350
 
                else if (if ((0 > amountEnrollA))
353
351
 
                    then true
354
352
 
                    else (0 > amountEnrollB))
355
353
 
                    then throw("Too large amountLeave")
356
354
 
                    else [IntegerEntry(keyBalanceA, (balanceA + amountEnrollA)), IntegerEntry(keyBalanceB, (balanceB + amountEnrollB))]
357
355
 
    }
358
356
 
359
357
 

github/deemru/w8io/786bc32 
79.51 ms ◑