tx · FK1y2xKxiAUbMRshXJdraYWPmsuKyDRAEqHZePcwzaZR

3MuAyo3UDyRW1uGJYpgNwKJx4rGPEQdHetK:  -0.02000000 Waves

2022.02.25 16:02 [1939189] smart account 3MuAyo3UDyRW1uGJYpgNwKJx4rGPEQdHetK > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "FK1y2xKxiAUbMRshXJdraYWPmsuKyDRAEqHZePcwzaZR",
    "fee": 2000000,
    "feeAssetId": null,
    "timestamp": 1645794208130,
    "version": 1,
    "sender": "3MuAyo3UDyRW1uGJYpgNwKJx4rGPEQdHetK",
    "senderPublicKey": "8JFUsgTkU5xXsm3gJYTdzsJwYfzBYbZsW7bgR1SYLmas",
    "proofs": [
        "56YHF5FtGAECQ9eqXZXTAzjAPa1c2UJzrR9aY9hzHoT8CF33aBrj6ukRnWjFBmJp74dHnpNEbNvT2TQ5YANkq3Ps"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 1939189,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 4LUCuohoifNSU1RLwqx7S4Lam5UPrmKZNzRPgWb9n159
Next: bAQn8apvFbpqjfLdoBRpvPr2KXhjUwdeQ7DacqTWm3H

Diff: 
Old
New
Differences
169
169
 
170
170
 
@Callable(i)
171
171
 
func calcSwapLimitMATH (gNsbtAmount) = {
172
-
    let usdnSwapDelayDuration = valueOrErrorMessage(getIntegerValue(this, keySwapAmountAParam()), "Swap parameter A missed.")
173
-
    let gNsbtAmountBigInt = toBigInt(gNsbtAmount)
174
-
    let limitPowPart = pow(gNsbtAmountBigInt, 0, toBigInt(EULERNUMBER), 8, 0, DOWN)
172
+
    let usdnSwapDelayDuration = 3
173
+
    let gNsbtAmountScale16 = toX16(gNsbtAmount, scale6)
174
+
    let eulerX16 = toX16(EULERNUMBER, MULT)
175
+
    let limitPowPart = pow(gNsbtAmountScale16, 16, eulerX16, 16, 8, DOWN)
175
176
 
    let limit = fraction(toBigInt(usdnSwapDelayDuration), limitPowPart, scale8BigInt)
176
177
 
    $Tuple2(nil, toInt(limit))
177
178
 
    }
Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 5 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
let WAVELET = 100000000
5
5
 
6
6
 
let PAULI = 1000000
7
7
 
8
8
 
let BIGPAULI = toBigInt(1000000)
9
9
 
10
10
 
let PRICELET = 1000000
11
11
 
12
12
 
let MULT = 100000000
13
13
 
14
14
 
let BIGMULT16 = toBigInt(10000000000000000)
15
15
 
16
16
 
let MULTSCALE = 8
17
17
 
18
18
 
let SCALE16 = 16
19
19
 
20
20
 
let SEP = "__"
21
21
 
22
22
 
let HALF8 = 50000000
23
23
 
24
24
 
let EULERNUMBER = 271828182
25
25
 
26
26
 
let scale6 = 1000000
27
27
 
28
28
 
let scale6BigInt = toBigInt(1000000)
29
29
 
30
30
 
let scale8BigInt = toBigInt(100000000)
31
31
 
32
32
 
func keyNeutrinoAddress () = "%s%s__config__neutrinoAddress"
33
33
 
34
34
 
35
35
 
func keySwapAmountAParam () = "%s%s__config__swapAParam"
36
36
 
37
37
 
38
38
 
func keyNeutrinoAssetId () = "neutrino_asset_id"
39
39
 
40
40
 
41
41
 
func keyLiquidationContractAddress () = "liquidation_contract"
42
42
 
43
43
 
44
44
 
func keyRPDContract () = "rpd_contract"
45
45
 
46
46
 
47
47
 
func keyAuctionContract () = "auction_contract"
48
48
 
49
49
 
50
50
 
func keyContolContract () = "control_contract"
51
51
 
52
52
 
53
53
 
func keyBondAssetId () = "bond_asset_id"
54
54
 
55
55
 
56
56
 
func keyBalanceLocked () = "balance_lock_"
57
57
 
58
58
 
59
59
 
func keyWavesLockedBalance () = (keyBalanceLocked() + "waves")
60
60
 
61
61
 
62
62
 
func keyNeutrinoLockedBalance () = (keyBalanceLocked() + "neutrino")
63
63
 
64
64
 
65
65
 
func keyMinWavesSwapAmount () = "min_waves_swap_amount"
66
66
 
67
67
 
68
68
 
func keyMinNeutrinoSwapAmount () = "min_neutrino_swap_amount"
69
69
 
70
70
 
71
71
 
func keyWavesOutFeePart () = "wavesOut_swap_feePart"
72
72
 
73
73
 
74
74
 
func keyNeutrinoOutFeePart () = "neutrinoOut_swap_feePart"
75
75
 
76
76
 
77
77
 
func keyNsbtLockContract () = "%s__nsbtLockContract"
78
78
 
79
79
 
80
80
 
func keyQuickSwapLimitDuration () = "%s__quickSwapLimitDuration"
81
81
 
82
82
 
83
83
 
func keyUserLastQuickSwapHeight (userAddress) = makeString(["%s%s", "userLastQuickSwapHeight", userAddress], SEP)
84
84
 
85
85
 
86
86
 
func keyQuickSwapUserSpentInPeriod (userAddress) = makeString(["%s%s", "quickSwapUserSpentInPeriod", userAddress], SEP)
87
87
 
88
88
 
89
89
 
func keyPrice () = "price"
90
90
 
91
91
 
92
92
 
func keyHalfLife () = "%s__halfLife"
93
93
 
94
94
 
95
95
 
func keyLockParamUserAmount (userAddress) = makeString(["%s%s%s", "paramByUser", userAddress, "amount"], SEP)
96
96
 
97
97
 
98
98
 
func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
99
99
 
100
100
 
101
101
 
func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
102
102
 
103
103
 
104
104
 
func getBoolOrFail (address,key) = valueOrErrorMessage(getBoolean(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
105
105
 
106
106
 
107
107
 
func convertNeutrinoToWaves (amount,price) = fraction(fraction(amount, PRICELET, price), WAVELET, PAULI)
108
108
 
109
109
 
110
110
 
func convertWavesToNeutrino (amount,price) = fraction(fraction(amount, price, PRICELET), PAULI, WAVELET)
111
111
 
112
112
 
113
113
 
func toX16 (origVal,origScaleMult) = fraction(toBigInt(origVal), BIGMULT16, toBigInt(origScaleMult))
114
114
 
115
115
 
116
116
 
func fromX16 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), BIGMULT16))
117
117
 
118
118
 
119
119
 
func asAnyList (val) = match val {
120
120
 
    case valAnyLyst: List[Any] => 
121
121
 
        valAnyLyst
122
122
 
    case _ => 
123
123
 
        throw("fail to cast into List[Any]")
124
124
 
}
125
125
 
126
126
 
127
127
 
func asInt (val) = match val {
128
128
 
    case valInt: Int => 
129
129
 
        valInt
130
130
 
    case _ => 
131
131
 
        throw("fail to cast into Int")
132
132
 
}
133
133
 
134
134
 
135
135
 
func asString (val) = match val {
136
136
 
    case valStr: String => 
137
137
 
        valStr
138
138
 
    case _ => 
139
139
 
        throw("fail to cast into String")
140
140
 
}
141
141
 
142
142
 
143
143
 
let neutrinoContract = addressFromStringValue(getStringOrFail(this, keyNeutrinoAddress()))
144
144
 
145
145
 
let controlContract = addressFromStringValue(getStringOrFail(neutrinoContract, keyContolContract()))
146
146
 
147
147
 
let auctionContract = addressFromStringValue(getStringOrFail(neutrinoContract, keyAuctionContract()))
148
148
 
149
149
 
let liquidationContract = getStringOrFail(neutrinoContract, keyLiquidationContractAddress())
150
150
 
151
151
 
let rpdContract = getStringOrFail(neutrinoContract, keyRPDContract())
152
152
 
153
153
 
let nsbtStakingContract = addressFromStringValue(getStringOrFail(this, keyNsbtLockContract()))
154
154
 
155
155
 
let neutrinoAssetIdString = getStringOrFail(neutrinoContract, keyNeutrinoAssetId())
156
156
 
157
157
 
let neutrinoAssetId = fromBase58String(neutrinoAssetIdString)
158
158
 
159
159
 
let nsbtAssetIdStr = getStringValue(neutrinoContract, keyBondAssetId())
160
160
 
161
161
 
let nsbtAssetId = fromBase58String(nsbtAssetIdStr)
162
162
 
163
163
 
@Callable(i)
164
164
 
func constructor (neutrinoAddress,nsbtLockAddress,swapAmountAParam) = if ((i.caller != this))
165
165
 
    then throw("not authorized")
166
166
 
    else [StringEntry(keyNeutrinoAddress(), neutrinoAddress), StringEntry(keyNsbtLockContract(), nsbtLockAddress), IntegerEntry(keySwapAmountAParam(), swapAmountAParam)]
167
167
 
168
168
 
169
169
 
170
170
 
@Callable(i)
171
171
 
func calcSwapLimitMATH (gNsbtAmount) = {
172
-
    let usdnSwapDelayDuration = valueOrErrorMessage(getIntegerValue(this, keySwapAmountAParam()), "Swap parameter A missed.")
173
-
    let gNsbtAmountBigInt = toBigInt(gNsbtAmount)
174
-
    let limitPowPart = pow(gNsbtAmountBigInt, 0, toBigInt(EULERNUMBER), 8, 0, DOWN)
172
+
    let usdnSwapDelayDuration = 3
173
+
    let gNsbtAmountScale16 = toX16(gNsbtAmount, scale6)
174
+
    let eulerX16 = toX16(EULERNUMBER, MULT)
175
+
    let limitPowPart = pow(gNsbtAmountScale16, 16, eulerX16, 16, 8, DOWN)
175
176
 
    let limit = fraction(toBigInt(usdnSwapDelayDuration), limitPowPart, scale8BigInt)
176
177
 
    $Tuple2(nil, toInt(limit))
177
178
 
    }
178
179
 
179
180
 
180
181
 
181
182
 
@Callable(i)
182
183
 
func calculateKMATH (wRaw,uRaw,price,mRaw,sRaw) = {
183
184
 
    let EXP = toBigInt(2718281)
184
185
 
    let EXPSCALE = 6
185
186
 
    let a = valueOrElse(getInteger(auctionContract, "nsbtCurveParam_a"), 3)
186
187
 
    let paulB = valueOrElse(getInteger(auctionContract, "nsbtCurveParam_b"), ((3 * PAULI) / 10))
187
188
 
    let wReservesInUsdn = convertWavesToNeutrino(wRaw, price)
188
189
 
    let multBR = fraction(wReservesInUsdn, MULT, uRaw)
189
190
 
    if ((multBR > 10678564816))
190
191
 
        then throw("BR > 10678.564816% will overflow exponent")
191
192
 
        else {
192
193
 
            let multPower = (a * (multBR - MULT))
193
194
 
            let multExpInPower = pow(EXP, EXPSCALE, toBigInt(multPower), MULTSCALE, SCALE16, DOWN)
194
195
 
            let multK = fraction(toBigInt(paulB), multExpInPower, BIGPAULI)
195
196
 
            $Tuple2(nil, [a, paulB, wReservesInUsdn, multBR, multPower, toString(multExpInPower), toString(multK)])
196
197
 
            }
197
198
 
    }
198
199
 
199
200
 
200
201
 
201
202
 
@Callable(i)
202
203
 
func curveFunctionMATH (wRaw,uRaw,price,mRaw,sRaw,wavesPayRaw) = {
203
204
 
    let kCalcArray = asAnyList(invoke(this, "calculateKMATH", [wRaw, uRaw, price, mRaw, sRaw], nil))
204
205
 
    if ((kCalcArray == kCalcArray))
205
206
 
        then {
206
207
 
            let multK = parseBigIntValue(asString(kCalcArray[6]))
207
208
 
            let usdnPay = convertWavesToNeutrino(wavesPayRaw, price)
208
209
 
            let bigMaxNsbtSupply = toBigInt(mRaw)
209
210
 
            let bigNsbtSupply = toBigInt((mRaw - sRaw))
210
211
 
            let step1 = fraction(toBigInt(usdnPay), BIGMULT16, multK)
211
212
 
            let step2 = fraction(step1, bigNsbtSupply, bigMaxNsbtSupply)
212
213
 
            let step3 = toInt(fraction(bigNsbtSupply, bigMaxNsbtSupply, (step2 + bigMaxNsbtSupply)))
213
214
 
            let nsbtAmountRaw = ((mRaw - sRaw) - step3)
214
215
 
            $Tuple2(nil, [nsbtAmountRaw, usdnPay, wRaw, uRaw, mRaw, sRaw, asInt(kCalcArray[0]), asInt(kCalcArray[1]), asInt(kCalcArray[2]), asInt(price), asInt(kCalcArray[3]), asInt(kCalcArray[4]), kCalcArray[5], kCalcArray[6], toString(step1), toString(step2), toString(step3)])
215
216
 
            }
216
217
 
        else throw("Strict value is not equal to itself.")
217
218
 
    }
218
219
 
219
220
 
220
221
 
221
222
 
@Callable(i)
222
223
 
func calcContractNsbtPriceMATH () = {
223
224
 
    let nsbtSupplyMAX = value(assetInfo(nsbtAssetId)).quantity
224
225
 
    let neutrinoMetrics = asAnyList(invoke(this, "calcNeutinoMetricsMATH", nil, nil))
225
226
 
    if ((neutrinoMetrics == neutrinoMetrics))
226
227
 
        then {
227
228
 
            let nsbtSupply = asInt(neutrinoMetrics[9])
228
229
 
            let currentPrice = asInt(neutrinoMetrics[0])
229
230
 
            let kCalcArray = asAnyList(invoke(this, "calculateKMATH", [asInt(neutrinoMetrics[4]), asInt(neutrinoMetrics[6]), currentPrice, nsbtSupplyMAX, nsbtSupply], nil))
230
231
 
            if ((kCalcArray == kCalcArray))
231
232
 
                then {
232
233
 
                    let multK = parseBigIntValue(asString(kCalcArray[6]))
233
234
 
                    let mK = fromX16(multK, MULT)
234
235
 
                    let multStep1 = fraction(nsbtSupplyMAX, MULT, (nsbtSupplyMAX - nsbtSupply))
235
236
 
                    let multStep2 = fraction(multStep1, multStep1, MULT)
236
237
 
                    let multNsbt2usdnPrice = fraction(mK, multStep2, MULT)
237
238
 
                    let nsbt2usdnPrice = fraction(multNsbt2usdnPrice, PAULI, MULT)
238
239
 
                    let nsbt2wavesPrice = fraction(nsbt2usdnPrice, PAULI, currentPrice)
239
240
 
                    $Tuple2(nil, [nsbt2usdnPrice, nsbt2wavesPrice])
240
241
 
                    }
241
242
 
                else throw("Strict value is not equal to itself.")
242
243
 
            }
243
244
 
        else throw("Strict value is not equal to itself.")
244
245
 
    }
245
246
 
246
247
 
247
248
 
248
249
 
@Callable(i)
249
250
 
func calcUserSwapLimitsMATH (userAddressStr) = {
250
251
 
    let userGNsbtAmount = valueOrElse(getInteger(nsbtStakingContract, keyLockParamUserAmount(userAddressStr)), 0)
251
252
 
    let usdnLmtMax = asInt(invoke(this, "calcSwapLimitMATH", [userGNsbtAmount], nil))
252
253
 
    if ((usdnLmtMax == usdnLmtMax))
253
254
 
        then {
254
255
 
            let quickSwapResetBlocks = getIntegerValue(neutrinoContract, keyQuickSwapLimitDuration())
255
256
 
            let lastQuickSwapBlock = valueOrElse(getInteger(neutrinoContract, keyUserLastQuickSwapHeight(userAddressStr)), 0)
256
257
 
            let isNewQuickSwapPeriod = ((height - lastQuickSwapBlock) > quickSwapResetBlocks)
257
258
 
            let quickSwapUserSpent = if (isNewQuickSwapPeriod)
258
259
 
                then 0
259
260
 
                else valueOrElse(getInteger(neutrinoContract, keyQuickSwapUserSpentInPeriod(userAddressStr)), 0)
260
261
 
            $Tuple2(nil, [usdnLmtMax, quickSwapUserSpent])
261
262
 
            }
262
263
 
        else throw("Strict value is not equal to itself.")
263
264
 
    }
264
265
 
265
266
 
266
267
 
267
268
 
@Callable(i)
268
269
 
func calcNeutinoMetricsMATH () = {
269
270
 
    let currentPrice = getIntegerValue(controlContract, keyPrice())
270
271
 
    let neutrinoLockedBalance = valueOrElse(getInteger(neutrinoContract, keyNeutrinoLockedBalance()), 0)
271
272
 
    let wavesLockedBalance = valueOrElse(getInteger(neutrinoContract, keyWavesLockedBalance()), 0)
272
273
 
    let reserve = (wavesBalance(neutrinoContract).regular - wavesLockedBalance)
273
274
 
    let reservesInUsdn = convertWavesToNeutrino(reserve, currentPrice)
274
275
 
    let neutrinoSupply = (((neutrinoLockedBalance + value(assetInfo(neutrinoAssetId)).quantity) - assetBalance(neutrinoContract, neutrinoAssetId)) - assetBalance(addressFromStringValue(liquidationContract), neutrinoAssetId))
275
276
 
    let surplus = (reservesInUsdn - neutrinoSupply)
276
277
 
    let deficit = (neutrinoSupply - reservesInUsdn)
277
278
 
    let surplusPercent = (fraction(surplus, PAULI, neutrinoSupply) * 100)
278
279
 
    let BR = fraction(reservesInUsdn, PAULI, neutrinoSupply)
279
280
 
    let nsbtSupplyMAX = value(assetInfo(nsbtAssetId)).quantity
280
281
 
    let nsbtSupply = (nsbtSupplyMAX - assetBalance(auctionContract, nsbtAssetId))
281
282
 
    $Tuple2(nil, [currentPrice, neutrinoLockedBalance, wavesLockedBalance, reserve, reservesInUsdn, neutrinoSupply, surplus, surplusPercent, BR, nsbtSupply, nsbtSupplyMAX])
282
283
 
    }
283
284
 
284
285
 
285
286
 
286
287
 
@Callable(i)
287
288
 
func getUnstakeComissionAmountMATH (amount,startHeight) = {
288
289
 
    let halfLife = getIntOrFail(nsbtStakingContract, keyHalfLife())
289
290
 
    $Tuple2(nil, fraction(amount, pow(2, 0, fraction(-((height - startHeight)), MULT, halfLife), 8, 8, HALFUP), MULT))
290
291
 
    }
291
292
 
292
293
 
293
294
 
294
295
 
@Callable(i)
295
296
 
func mergeStakesMATH (amount1,height1,amount2,height2) = {
296
297
 
    let halfLife = getIntOrFail(nsbtStakingContract, keyHalfLife())
297
298
 
    let w = fraction(amount2, pow(2, 0, fraction((height2 - height1), MULT, halfLife), 8, 8, HALFUP), MULT)
298
299
 
    let v = fraction((amount1 + amount2), MULT, (amount1 + w))
299
300
 
    $Tuple2(nil, (height1 + ((HALF8 - (halfLife * log(v, 8, 2, 0, 8, HALFUP))) / MULT)))
300
301
 
    }
301
302
 
302
303
 

github/deemru/w8io/3ef1775 
64.06 ms ◑