2022.12.02 20:09 [3408487] smart account 3PKpsc1TNquw4HAF62pWK8ka1DBz9vyEBkt > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "J6YGvoLyetNcouWxfyCCLrJy5mDjE9EnDLH7rWSRcLjU",
    "fee": 3500000,
    "feeAssetId": null,
    "timestamp": 1670000734741,
    "version": 1,
    "sender": "3PKpsc1TNquw4HAF62pWK8ka1DBz9vyEBkt",
    "senderPublicKey": "8ZLAVkwG8sZ97hmBdGRkQpYTp5En9xgEYX4PeupqxpFw",
    "proofs": [
        "29UtRNrmqPxRT3BqknoyzqjrYnovAGhyGwxs3vc4LZZ9ci8XzCuFKJj6pgT3zwB9u24eYe412wktzdbZnyMzXWWd"
    ],
    "script": "base64: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",
    "chainId": 87,
    "height": 3408487,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: G1aBFYzozkdmu4ZkQ1EssN594NX4Bsa64NYD6VvRU4ZW
Next: 5NcwC6LQDrx48AUrS9zWCsQH332zWc3P4H3Q1QVJvgJ

Diff: 
Old
New
Differences
508
508
 
                                                    let totals = readTotalsArrayOrDefault()
509
509
 
                                                    let totalsTotalAmount = parseIntValue(totals[IdxInvTotalAmount])
510
510
 
                                                    let totalsRemainingAmount = parseIntValue(totals[IdxInvRemainingAmount])
511
-
                                                    let totalsClaimedPriceAssetAmount = parseIntValue(totals[IdxInvRemainingAmount])
512
-
                                                    let totalsClaimedIdoAssetAmount = parseIntValue(totals[IdxInvClaimedPriceAssetAmount])
511
+
                                                    let totalsClaimedPriceAssetAmount = parseIntValue(totals[IdxInvClaimedPriceAssetAmount])
512
+
                                                    let totalsClaimedIdoAssetAmount = parseIntValue(totals[IdxInvClaimedIdoAssetAmount])
513
513
 
                                                    let totalsLastClaimedHeight = parseIntValue(totals[IdxInvLastClaimedHeight])
514
514
 
                                                    let newTotalsRemainingAmount = (totalsRemainingAmount - investorRemainingAmount)
515
515
 
                                                    let newTotalArray = [toString(totalsTotalAmount), toString(newTotalsRemainingAmount), toString(totalsClaimedPriceAssetAmount), toString(totalsClaimedIdoAssetAmount), toString(totalsLastClaimedHeight)]
532
532
 
                    }
533
533
 
            entries
534
534
 
            }
535
+
    }
536
+
537
+
538
+
539
+
@Callable(i)
540
+
func cleanRemaingAmount (userAddress58) = {
541
+
    let priceAssetId58 = readConfigArray()[IdxCfgPriceAssetId]
542
+
    let evaluateResult = split(asString(invoke(this, "claimREADONLY", [priceAssetId58, userAddress58], nil)), SEP)
543
+
    if ((evaluateResult == evaluateResult))
544
+
        then {
545
+
            let availablePriceAmountToClaim = parseIntValue(evaluateResult[2])
546
+
            let checkUnclaimedAssets = if ((availablePriceAmountToClaim == 0))
547
+
                then true
548
+
                else throwErr("user have unclaimed assets")
549
+
            if ((checkUnclaimedAssets == checkUnclaimedAssets))
550
+
                then {
551
+
                    let investor = split(value(getString(keyInvestor(userAddress58))), SEP)
552
+
                    let investorTotalAmount = parseIntValue(investor[IdxInvTotalAmount])
553
+
                    let investorRemainingAmount = parseIntValue(investor[IdxInvRemainingAmount])
554
+
                    let investorPriceAssetBalance = parseIntValue(investor[IdxInvClaimedPriceAssetAmount])
555
+
                    let investorIdoAssetBalance = parseIntValue(investor[IdxInvClaimedIdoAssetAmount])
556
+
                    let investorLastClaimedHeight = parseIntValue(investor[IdxInvLastClaimedHeight])
557
+
                    let investorRemainingAmountCheck = if ((investorRemainingAmount != 0))
558
+
                        then true
559
+
                        else throwErr("investorRemainingAmount already zero")
560
+
                    if ((investorRemainingAmountCheck == investorRemainingAmountCheck))
561
+
                        then {
562
+
                            let newInvestor = makeString(["%d%d%d%d%d", toString(investorTotalAmount), "0", toString(investorPriceAssetBalance), toString(investorIdoAssetBalance), toString(investorLastClaimedHeight)], SEP)
563
+
                            let totals = split(value(getString(keyTotals())), SEP)
564
+
                            let totalsTotalAmount = parseIntValue(totals[IdxInvTotalAmount])
565
+
                            let totalsRemainingAmount = parseIntValue(totals[IdxInvRemainingAmount])
566
+
                            let totalsClaimedPriceAssetAmount = parseIntValue(totals[IdxInvClaimedPriceAssetAmount])
567
+
                            let totalsClaimedIdoAssetAmount = parseIntValue(totals[IdxInvClaimedIdoAssetAmount])
568
+
                            let totalsLastClaimedHeight = parseIntValue(totals[IdxInvLastClaimedHeight])
569
+
                            let newTotals = makeString(["%d%d%d%d%d", toString(totalsTotalAmount), toString((totalsRemainingAmount - investorRemainingAmount)), toString(totalsClaimedPriceAssetAmount), toString(totalsClaimedIdoAssetAmount), toString(totalsLastClaimedHeight)], SEP)
570
+
                            let newTotalRemainingAmount = (valueOrElse(getInteger(keyTotalRemainingAmount()), 0) + investorRemainingAmount)
571
+
[StringEntry(keyInvestorRemainingAmount(userAddress58), toString(investorRemainingAmount)), StringEntry(keyTotalRemainingAmount(), toString(newTotalRemainingAmount)), StringEntry(keyInvestor(userAddress58), newInvestor), StringEntry(keyTotals(), newTotals)]
572
+
                            }
573
+
                        else throw("Strict value is not equal to itself.")
574
+
                    }
575
+
                else throw("Strict value is not equal to itself.")
576
+
            }
577
+
        else throw("Strict value is not equal to itself.")
535
578
 
    }
536
579
 
537
580
 
568
611
 
    let priceAssetBalance = valueOrElse(getInteger(keyPriceAssetBalance(userAddress58)), 0)
569
612
 
    let priceAssetBalanceIdoDecimals = (priceAssetBalance * 100)
570
613
 
    let availableIdoAmountToClaimWithPriceAssetBalance = (availableIdoAmountToClaim + priceAssetBalanceIdoDecimals)
571
-
    let $t03128231694 = internalClaimV2(priceAssetId58, userAddress58, outAmount, totalsDiff[IdxDiffClaimedPriceAmountIncrement])
572
-
    let periodMinAvailableToClaim = $t03128231694._1
573
-
    let periodTotalAvailableToClaim = $t03128231694._2
574
-
    let periodUserAvailableToClaim = $t03128231694._3
575
-
    let totalUserAvailableToClaim = $t03128231694._4
576
-
    let usdtPriceAssetAllowableRatio = $t03128231694._5
577
-
    let currentUsdtPriceAssetRatio = $t03128231694._6
578
-
    let endPeriodBlocksLeft = $t03128231694._7
579
-
    let updatedCurrentPeriod = $t03128231694._8
580
-
    let periodStart = $t03128231694._9
581
-
    let periodEnd = $t03128231694._10
614
+
    let $t03374934161 = internalClaimV2(priceAssetId58, userAddress58, outAmount, totalsDiff[IdxDiffClaimedPriceAmountIncrement])
615
+
    let periodMinAvailableToClaim = $t03374934161._1
616
+
    let periodTotalAvailableToClaim = $t03374934161._2
617
+
    let periodUserAvailableToClaim = $t03374934161._3
618
+
    let totalUserAvailableToClaim = $t03374934161._4
619
+
    let usdtPriceAssetAllowableRatio = $t03374934161._5
620
+
    let currentUsdtPriceAssetRatio = $t03374934161._6
621
+
    let endPeriodBlocksLeft = $t03374934161._7
622
+
    let updatedCurrentPeriod = $t03374934161._8
623
+
    let periodStart = $t03374934161._9
624
+
    let periodEnd = $t03374934161._10
582
625
 
    let currentPeriodEndHeight = valueOrElse(getInteger(keyPeriodEndHeight(updatedCurrentPeriod)), 0)
583
626
 
    let userTotalPriceAssetClaimed = (parseIntValue(readInvestorArrayOrFail(userAddress58)[IdxInvClaimedPriceAssetAmount]) - priceAssetBalance)
584
627
 
    let resultString = if ((height > currentPeriodEndHeight))
Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 6 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
func getStringOrFail (key) = valueOrErrorMessage(getString(key), (("mandatory this." + key) + " is not defined"))
5
5
 
6
6
 
7
7
 
let SEP = "__"
8
8
 
9
9
 
let BUFSCALE = toBigInt(1000000000000000000)
10
10
 
11
11
 
let scale8 = 100000000
12
12
 
13
13
 
func throwErr (msg) = throw(makeString(["ido.ride:", msg], " "))
14
14
 
15
15
 
16
16
 
func asString (val) = match val {
17
17
 
    case valStr: String => 
18
18
 
        valStr
19
19
 
    case _ => 
20
20
 
        throw("fail to cast into String")
21
21
 
}
22
22
 
23
23
 
24
24
 
func convertPriceAssetIntoIdoAsset (priceAssetAmount,priceAssetMULT,price,priceMULT,idoAssetMULT) = {
25
25
 
    let bPriceAssetMULT = toBigInt(priceAssetMULT)
26
26
 
    let bIdoAssetMULT = toBigInt(idoAssetMULT)
27
27
 
    let bPriceAssetBUF = fraction(toBigInt(priceAssetAmount), BUFSCALE, bPriceAssetMULT)
28
28
 
    let bAmountAssetBUF = fraction(bPriceAssetBUF, toBigInt(priceMULT), toBigInt(price))
29
29
 
    toInt(fraction(bAmountAssetBUF, toBigInt(idoAssetMULT), BUFSCALE))
30
30
 
    }
31
31
 
32
32
 
33
33
 
let IdxCfgIdoStart = 1
34
34
 
35
35
 
let IdxCfgIdoDuration = 2
36
36
 
37
37
 
let IdxCfgClaimStart = 3
38
38
 
39
39
 
let IdxCfgClaimDuration = 4
40
40
 
41
41
 
let IdxCfgPrice = 5
42
42
 
43
43
 
let IdxCfgPriceMult = 6
44
44
 
45
45
 
let IdxCfgIdoAssetId = 7
46
46
 
47
47
 
let IdxCfgIdoAssetMult = 8
48
48
 
49
49
 
let IdxCfgPriceAssetId = 9
50
50
 
51
51
 
let IdxCfgPriceAssetMult = 10
52
52
 
53
53
 
let IdxCfgMinInvestAmount = 11
54
54
 
55
55
 
func fromatConfigS (idoStart,idoDuration,claimStart,claimDuration,price,priceMult,idoAssetId58,idoAssetMult,priceAssetId58,priceAssetMult,minInvestAmount,totalIdoAssetToSell) = makeString(["%d%d%d%d%d%d%s%d%s%d%d%d", idoStart, idoDuration, claimStart, claimDuration, price, priceMult, idoAssetId58, idoAssetMult, priceAssetId58, priceAssetMult, minInvestAmount, totalIdoAssetToSell], SEP)
56
56
 
57
57
 
58
58
 
func fromatConfig (idoStart,idoDuration,claimStart,claimDuration,price,priceMult,idoAssetId58,idoAssetMult,priceAssetId58,priceAssetMult,minInvestAmount,totalIdoAssetToSell) = fromatConfigS(toString(idoStart), toString(idoDuration), toString(claimStart), toString(claimDuration), toString(price), toString(priceMult), idoAssetId58, toString(idoAssetMult), priceAssetId58, toString(priceAssetMult), toString(minInvestAmount), toString(totalIdoAssetToSell))
59
59
 
60
60
 
61
61
 
let IdxInvTotalAmount = 1
62
62
 
63
63
 
let IdxInvRemainingAmount = 2
64
64
 
65
65
 
let IdxInvClaimedPriceAssetAmount = 3
66
66
 
67
67
 
let IdxInvClaimedIdoAssetAmount = 4
68
68
 
69
69
 
let IdxInvLastClaimedHeight = 5
70
70
 
71
71
 
func formatInvestorS (totalAmount,remainingAmount,claimedPriceAssetAmount,claimedIdoAssetAmount,lastClaimedHeight) = makeString(["%d%d%d%d%d", totalAmount, remainingAmount, claimedPriceAssetAmount, claimedIdoAssetAmount, lastClaimedHeight], SEP)
72
72
 
73
73
 
74
74
 
func formatInvestor (totalAmount,remainingAmount,claimedPriceAssetAmount,claimedIdoAssetAmount,lastClaimedHeight) = formatInvestorS(toString(totalAmount), toString(remainingAmount), toString(claimedPriceAssetAmount), toString(claimedIdoAssetAmount), toString(lastClaimedHeight))
75
75
 
76
76
 
77
77
 
func formatHistoryRecord (priceAssetAmount,idoAssetAmount) = makeString(["%d%d%d%d", toString(height), toString(lastBlock.timestamp), toString(priceAssetAmount), toString(idoAssetAmount)], SEP)
78
78
 
79
79
 
80
80
 
func keyConfig () = "%s__config"
81
81
 
82
82
 
83
83
 
func keyInvestor (userAddress) = ("%s__" + userAddress)
84
84
 
85
85
 
86
86
 
func keyTotals () = "%s__totals"
87
87
 
88
88
 
89
89
 
func keyOperationHistoryRecord (type,userAddress,txId58) = makeString(["%s%s%s%s__history", type, userAddress, txId58], SEP)
90
90
 
91
91
 
92
92
 
func keyUSDNClaimDisabled () = "%s__usdnClaimDisabled"
93
93
 
94
94
 
95
95
 
func keyUSDNClaimEndHeight () = "%s__usdnClaimEndHeight"
96
96
 
97
97
 
98
98
 
func keyPeriodLength () = makeString(["%s", "periodLength"], SEP)
99
99
 
100
100
 
101
101
 
func keyCurrentPeriod () = makeString(["%s", "currentPeriod"], SEP)
102
102
 
103
103
 
104
104
 
func keyPeriodStartHeight (periodNum) = makeString(["%s%s", "periodStartHeight", toString(periodNum)], SEP)
105
105
 
106
106
 
107
107
 
func keyPeriodEndHeight (periodNum) = makeString(["%s%s", "periodEndHeight", toString(periodNum)], SEP)
108
108
 
109
109
 
110
110
 
func keyUsdtPriceAssetAllowableRatio () = makeString(["%s", "usdtPriceAssetAllowableRatio"], SEP)
111
111
 
112
112
 
113
113
 
func keyTotalPeriodAllowance (assetId) = makeString(["%s%s", "totalPeriodAllowance", assetId], SEP)
114
114
 
115
115
 
116
116
 
func keyUserPeriodAllowance (assetId) = makeString(["%s%s", "userPeriodAllowance", assetId], SEP)
117
117
 
118
118
 
119
119
 
func keyPeriodTotalAvailableToClaim (assetId,periodNum) = makeString(["%s%s%s", "periodTotalAvailableToClaim", assetId, toString(periodNum)], SEP)
120
120
 
121
121
 
122
122
 
func keyPeriodUserAvailableToClaim (assetId,periodNum,userAddress) = makeString(["%s%s%s%s", "periodUserAvailableToClaim", assetId, toString(periodNum), userAddress], SEP)
123
123
 
124
124
 
125
125
 
func keyUsdtPriceAssetStablePool () = makeString(["%s", "usdtPriceAssetStablePool"], SEP)
126
126
 
127
127
 
128
128
 
func keyUsdtAssetId () = makeString(["%s", "usdtAssetId"], SEP)
129
129
 
130
130
 
131
131
 
func keyPriceAssetBalance (address) = makeString(["%s%s", "priceAssetBalance", address], SEP)
132
132
 
133
133
 
134
134
 
func keyInvestorRemainingAmount (address) = makeString(["%s%s", "investorRemainingAmount", address], SEP)
135
135
 
136
136
 
137
137
 
func keyTotalRemainingAmount () = makeString(["%s", "totalRemainingAmount"], SEP)
138
138
 
139
139
 
140
140
 
func keyManagerPublicKey () = "%s__managerPublicKey"
141
141
 
142
142
 
143
143
 
func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
144
144
 
145
145
 
146
146
 
func readConfigArray () = split(getStringOrFail(keyConfig()), SEP)
147
147
 
148
148
 
149
149
 
func readTotalsArrayOrDefaultByCustomKey (customKey) = split(valueOrElse(getString(customKey), formatInvestorS("0", "0", "0", "0", "0")), SEP)
150
150
 
151
151
 
152
152
 
func readTotalsArrayOrDefault () = readTotalsArrayOrDefaultByCustomKey(keyTotals())
153
153
 
154
154
 
155
155
 
func readInvestorArrayOrDefault (userAddress) = readTotalsArrayOrDefaultByCustomKey(keyInvestor(userAddress))
156
156
 
157
157
 
158
158
 
func readInvestorArrayOrFail (userAddress) = split(getStringOrFail(keyInvestor(userAddress)), SEP)
159
159
 
160
160
 
161
161
 
let IdxDiffTotalIncrement = 0
162
162
 
163
163
 
let IdxDiffRemainingPriceAmountIncrement = 1
164
164
 
165
165
 
let IdxDiffClaimedPriceAmountIncrement = 2
166
166
 
167
167
 
let IdxDiffClaimedIdoAssetAmountIncrement = 3
168
168
 
169
169
 
func TotalsEntry (key,origArray,incrementDiff,newLastClaimedHeight,priceAssetBalance) = {
170
170
 
    let totalAmount = parseIntValue(origArray[IdxInvTotalAmount])
171
171
 
    let remainingAmount = parseIntValue(origArray[IdxInvRemainingAmount])
172
172
 
    let claimedPriceAssetAmount = parseIntValue(origArray[IdxInvClaimedPriceAssetAmount])
173
173
 
    let claimedIdoAssetAmount = parseIntValue(origArray[IdxInvClaimedIdoAssetAmount])
174
174
 
    let lastClaimedHeight = parseIntValue(origArray[IdxInvLastClaimedHeight])
175
175
 
    let newTotalAmount = (totalAmount + incrementDiff[IdxDiffTotalIncrement])
176
176
 
    let newRemainingAmount = (remainingAmount + incrementDiff[IdxDiffRemainingPriceAmountIncrement])
177
177
 
    let cfgArray = readConfigArray()
178
178
 
    let priceAssetId58 = cfgArray[IdxCfgPriceAssetId]
179
179
 
    let priceAssetDecimals = value(assetInfo(fromBase58String(priceAssetId58))).decimals
180
180
 
    let priceAssetBalancePriceAssetDecimals = fraction(priceAssetBalance, scale8, pow(10, 0, priceAssetDecimals, 0, 0, DOWN))
181
181
 
    let newClaimedPriceAssetAmount = ((claimedPriceAssetAmount + incrementDiff[IdxDiffClaimedPriceAmountIncrement]) - priceAssetBalance)
182
182
 
    let newClaimedIdoAssetAmount = ((claimedIdoAssetAmount + incrementDiff[IdxDiffClaimedIdoAssetAmountIncrement]) + priceAssetBalancePriceAssetDecimals)
183
183
 
    let entries = if ((0 > newRemainingAmount))
184
184
 
        then {
185
185
 
            let diff = ((newTotalAmount - newClaimedPriceAssetAmount) - newClaimedIdoAssetAmount)
186
186
 
            let newLogicRemainingAmount = if ((0 > diff))
187
187
 
                then 0
188
188
 
                else diff
189
189
 
            StringEntry(key, formatInvestor(newTotalAmount, newLogicRemainingAmount, newClaimedPriceAssetAmount, newClaimedIdoAssetAmount, newLastClaimedHeight))
190
190
 
            }
191
191
 
        else StringEntry(key, formatInvestor(newTotalAmount, newRemainingAmount, newClaimedPriceAssetAmount, newClaimedIdoAssetAmount, newLastClaimedHeight))
192
192
 
    entries
193
193
 
    }
194
194
 
195
195
 
196
196
 
func InvestOperationHistoryEntry (userAddress,priceAssetAmount,idoAssetAmount,txId) = StringEntry(keyOperationHistoryRecord("invest", userAddress, toBase58String(txId)), formatHistoryRecord(priceAssetAmount, idoAssetAmount))
197
197
 
198
198
 
199
199
 
func ClaimOperationHistoryEntry (userAddress,priceAssetAmount,idoAssetAmount,txId) = StringEntry(keyOperationHistoryRecord("claim", userAddress, toBase58String(txId)), formatHistoryRecord(priceAssetAmount, idoAssetAmount))
200
200
 
201
201
 
202
202
 
func internalClaim (claimedAssetId58,userAddress,txId) = {
203
203
 
    let cfgArray = readConfigArray()
204
204
 
    let claimStart = parseIntValue(cfgArray[IdxCfgClaimStart])
205
205
 
    let claimDuration = parseIntValue(cfgArray[IdxCfgClaimDuration])
206
206
 
    let claimEnd = (claimStart + claimDuration)
207
207
 
    let price = parseIntValue(cfgArray[IdxCfgPrice])
208
208
 
    let priceMult = parseIntValue(cfgArray[IdxCfgPriceMult])
209
209
 
    let idoAssetId58 = cfgArray[IdxCfgIdoAssetId]
210
210
 
    let idoAssetId = fromBase58String(idoAssetId58)
211
211
 
    let idoAssetMult = parseIntValue(cfgArray[IdxCfgIdoAssetMult])
212
212
 
    let priceAssetId58 = cfgArray[IdxCfgPriceAssetId]
213
213
 
    let priceAssetId = fromBase58String(priceAssetId58)
214
214
 
    let priceAssetMult = parseIntValue(cfgArray[IdxCfgPriceAssetMult])
215
215
 
    let userAddress58 = toString(userAddress)
216
216
 
    let origInvestArray = readInvestorArrayOrFail(userAddress58)
217
217
 
    let investTotalAmount = parseIntValue(origInvestArray[IdxInvTotalAmount])
218
218
 
    let investLastClaimedHeightTMP = parseIntValue(origInvestArray[IdxInvLastClaimedHeight])
219
219
 
    let investLastClaimedHeight = if ((claimStart >= investLastClaimedHeightTMP))
220
220
 
        then claimStart
221
221
 
        else investLastClaimedHeightTMP
222
222
 
    let newClaimPeriodHeight = if ((height > claimEnd))
223
223
 
        then claimEnd
224
224
 
        else if ((claimStart > height))
225
225
 
            then claimStart
226
226
 
            else height
227
227
 
    let claimingBlocks = (newClaimPeriodHeight - investLastClaimedHeight)
228
228
 
    let claimingPriceAssetAmount = fraction(investTotalAmount, claimingBlocks, claimDuration)
229
229
 
    let claimingIdoAssetAmount = convertPriceAssetIntoIdoAsset(claimingPriceAssetAmount, priceAssetMult, price, priceMult, idoAssetMult)
230
230
 
    let isUSDN = (claimedAssetId58 == priceAssetId58)
231
231
 
    let isUSDNClaimDisabled = valueOrElse(getBoolean(keyUSDNClaimDisabled()), false)
232
232
 
    let checks = [if (!(if (isUSDN)
233
233
 
        then isUSDNClaimDisabled
234
234
 
        else false))
235
235
 
        then true
236
236
 
        else throw("USDN claim is disabled")]
237
237
 
    if ((checks == checks))
238
238
 
        then if ((claimedAssetId58 == priceAssetId58))
239
239
 
            then $Tuple6([0, -(claimingPriceAssetAmount), claimingPriceAssetAmount, 0], claimingPriceAssetAmount, priceAssetId, origInvestArray, newClaimPeriodHeight, [claimingPriceAssetAmount, claimingIdoAssetAmount])
240
240
 
            else if ((claimedAssetId58 == idoAssetId58))
241
241
 
                then $Tuple6([0, -(claimingPriceAssetAmount), 0, claimingIdoAssetAmount], claimingIdoAssetAmount, idoAssetId, origInvestArray, newClaimPeriodHeight, [claimingPriceAssetAmount, claimingIdoAssetAmount])
242
242
 
                else throw(("unsupported assetId: " + claimedAssetId58))
243
243
 
        else throw("Strict value is not equal to itself.")
244
244
 
    }
245
245
 
246
246
 
247
247
 
func internalClaimV2 (priceAssetId58,userAddress58,outAmount,totalUserAvailableToClaim) = {
248
248
 
    let totalPeriodPriceAssetAllowance = value(getInteger(keyTotalPeriodAllowance(priceAssetId58)))
249
249
 
    let userPeriodPriceAssetAllowance = value(getInteger(keyUserPeriodAllowance(priceAssetId58)))
250
250
 
    let periodLength = value(getInteger(keyPeriodLength()))
251
251
 
    let currentPeriod = valueOrElse(getInteger(keyCurrentPeriod()), 0)
252
252
 
    let zeroPeriodEndHeighIsDefined = isDefined(getInteger(keyPeriodEndHeight(0)))
253
253
 
    let $t01298714857 = if ((currentPeriod > 0))
254
254
 
        then {
255
255
 
            let lastPeriodStartHeight = value(getInteger(keyPeriodStartHeight(currentPeriod)))
256
256
 
            let lastPeriodEndHeight = value(getInteger(keyPeriodEndHeight(currentPeriod)))
257
257
 
            let $t01324713952 = if ((height > lastPeriodEndHeight))
258
258
 
                then {
259
259
 
                    let updatedCurrentPeriod = (currentPeriod + 1)
260
260
 
                    let periodStart = if ((height > (lastPeriodEndHeight + periodLength)))
261
261
 
                        then {
262
262
 
                            let blocksToLastPeriodStart = ((height - lastPeriodEndHeight) % periodLength)
263
263
 
                            if ((blocksToLastPeriodStart == 0))
264
264
 
                                then ((height - periodLength) + 1)
265
265
 
                                else (height - blocksToLastPeriodStart)
266
266
 
                            }
267
267
 
                        else (lastPeriodEndHeight + 1)
268
268
 
                    let periodEnd = ((periodStart + periodLength) - 1)
269
269
 
                    $Tuple3(updatedCurrentPeriod, periodStart, periodEnd)
270
270
 
                    }
271
271
 
                else $Tuple3(currentPeriod, lastPeriodStartHeight, lastPeriodEndHeight)
272
272
 
            let updatedCurrentPeriod = $t01324713952._1
273
273
 
            let periodStart = $t01324713952._2
274
274
 
            let periodEnd = $t01324713952._3
275
275
 
            $Tuple3(updatedCurrentPeriod, periodStart, periodEnd)
276
276
 
            }
277
277
 
        else if (zeroPeriodEndHeighIsDefined)
278
278
 
            then {
279
279
 
                let zeroPeriodStartHeight = value(getInteger(keyPeriodStartHeight(0)))
280
280
 
                let zeroPeriodEndHeight = value(getInteger(keyPeriodEndHeight(0)))
281
281
 
                let $t01420714589 = if ((height > zeroPeriodEndHeight))
282
282
 
                    then {
283
283
 
                        let updatedCurrentPeriod = (currentPeriod + 1)
284
284
 
                        let periodStart = (zeroPeriodEndHeight + 1)
285
285
 
                        let periodEnd = ((periodStart + periodLength) - 1)
286
286
 
                        $Tuple3(updatedCurrentPeriod, periodStart, periodEnd)
287
287
 
                        }
288
288
 
                    else $Tuple3(currentPeriod, zeroPeriodStartHeight, zeroPeriodEndHeight)
289
289
 
                let updatedCurrentPeriod = $t01420714589._1
290
290
 
                let periodStart = $t01420714589._2
291
291
 
                let periodEnd = $t01420714589._3
292
292
 
                $Tuple3(updatedCurrentPeriod, periodStart, periodEnd)
293
293
 
                }
294
294
 
            else $Tuple3(currentPeriod, valueOrElse(getInteger(keyPeriodStartHeight(currentPeriod)), height), valueOrElse(getInteger(keyPeriodEndHeight(currentPeriod)), ((height + periodLength) - 1)))
295
295
 
    let updatedCurrentPeriod = $t01298714857._1
296
296
 
    let periodStart = $t01298714857._2
297
297
 
    let periodEnd = $t01298714857._3
298
298
 
    let periodTotalAvailableToClaim = valueOrElse(getInteger(keyPeriodTotalAvailableToClaim(priceAssetId58, updatedCurrentPeriod)), totalPeriodPriceAssetAllowance)
299
299
 
    let periodUserAvailableToClaim = valueOrElse(getInteger(keyPeriodUserAvailableToClaim(priceAssetId58, updatedCurrentPeriod, userAddress58)), userPeriodPriceAssetAllowance)
300
300
 
    let priceAssetBalance = valueOrElse(getInteger(keyPriceAssetBalance(userAddress58)), 0)
301
301
 
    let periodMinAvailableToClaim = min([(outAmount + priceAssetBalance), periodTotalAvailableToClaim, periodUserAvailableToClaim])
302
302
 
    let usdtPriceAssetAllowableRatio = value(getInteger(keyUsdtPriceAssetAllowableRatio()))
303
303
 
    let putOneTknV2PriceAssetAmount = scale8
304
304
 
    let $t01561215865 = {
305
305
 
        let @ = invoke(addressFromStringValue(value(getString(keyUsdtPriceAssetStablePool()))), "putOneTknV2WithoutTakeFeeREADONLY", [putOneTknV2PriceAssetAmount, priceAssetId58], nil)
306
306
 
        if ($isInstanceOf(@, "(Int, Int, Int)"))
307
307
 
            then @
308
308
 
            else throw(($getType(@) + " couldn't be cast to (Int, Int, Int)"))
309
309
 
        }
310
310
 
    if (($t01561215865 == $t01561215865))
311
311
 
        then {
312
312
 
            let bonus = $t01561215865._3
313
313
 
            let feeAmount = $t01561215865._2
314
314
 
            let lpAmount = $t01561215865._1
315
315
 
            let usdtAssetId = value(getString(keyUsdtAssetId()))
316
316
 
            let $t01592716145 = {
317
317
 
                let @ = invoke(addressFromStringValue(value(getString(keyUsdtPriceAssetStablePool()))), "getOneTknV2READONLY", [usdtAssetId, lpAmount], nil)
318
318
 
                if ($isInstanceOf(@, "(Int, Int)"))
319
319
 
                    then @
320
320
 
                    else throw(($getType(@) + " couldn't be cast to (Int, Int)"))
321
321
 
                }
322
322
 
            if (($t01592716145 == $t01592716145))
323
323
 
                then {
324
324
 
                    let getOneTknV2FeeAmount = $t01592716145._2
325
325
 
                    let usdtAmount = $t01592716145._1
326
326
 
                    let currentUsdtPriceAssetRatio = fraction(putOneTknV2PriceAssetAmount, scale8, usdtAmount)
327
327
 
                    let endPeriodBlocksLeft = (periodEnd - height)
328
328
 
                    $Tuple10(periodMinAvailableToClaim, periodTotalAvailableToClaim, periodUserAvailableToClaim, totalUserAvailableToClaim, usdtPriceAssetAllowableRatio, currentUsdtPriceAssetRatio, endPeriodBlocksLeft, updatedCurrentPeriod, periodStart, periodEnd)
329
329
 
                    }
330
330
 
                else throw("Strict value is not equal to itself.")
331
331
 
            }
332
332
 
        else throw("Strict value is not equal to itself.")
333
333
 
    }
334
334
 
335
335
 
336
336
 
func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
337
337
 
    case s: String => 
338
338
 
        fromBase58String(s)
339
339
 
    case _: Unit => 
340
340
 
        unit
341
341
 
    case _ => 
342
342
 
        throw("Match error")
343
343
 
}
344
344
 
345
345
 
346
346
 
func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
347
347
 
    case s: String => 
348
348
 
        fromBase58String(s)
349
349
 
    case _: Unit => 
350
350
 
        unit
351
351
 
    case _ => 
352
352
 
        throw("Match error")
353
353
 
}
354
354
 
355
355
 
356
356
 
func mustManager (i) = {
357
357
 
    let pd = throw("Permission denied")
358
358
 
    match managerPublicKeyOrUnit() {
359
359
 
        case pk: ByteVector => 
360
360
 
            if ((i.callerPublicKey == pk))
361
361
 
                then true
362
362
 
                else pd
363
363
 
        case _: Unit => 
364
364
 
            if ((i.caller == this))
365
365
 
                then true
366
366
 
                else pd
367
367
 
        case _ => 
368
368
 
            throw("Match error")
369
369
 
    }
370
370
 
    }
371
371
 
372
372
 
373
373
 
@Callable(i)
374
374
 
func constructor (idoStart,idoDuration,claimStart,claimDuration,price,priceAssetId58,minInvestAmount) = {
375
375
 
    let priceMult = ((100 * 1000) * 1000)
376
376
 
    let idoEnd = (idoStart + idoDuration)
377
377
 
    if (isDefined(getString(keyConfig())))
378
378
 
        then throw("already initialized")
379
379
 
        else if (("3PMEHLx1j6zerarZTYfsGqDeeZqQoMpxq5S" != toString(i.caller)))
380
380
 
            then throw("not authorized")
381
381
 
            else if ((size(i.payments) != 1))
382
382
 
                then throw("exactly 1 payment must be attached")
383
383
 
                else if ((idoEnd >= claimStart))
384
384
 
                    then throw("claimStart must be greater than idoEnd")
385
385
 
                    else {
386
386
 
                        let pmt = value(i.payments[0])
387
387
 
                        let idoAssetId = value(pmt.assetId)
388
388
 
                        let idoAssetInfo = valueOrErrorMessage(assetInfo(idoAssetId), "fail to load ido asset info")
389
389
 
                        let idoAssetId58 = toBase58String(idoAssetId)
390
390
 
                        let idoAssetMult = pow(10, 0, idoAssetInfo.decimals, 0, 0, DOWN)
391
391
 
                        let priceAssetId = fromBase58String(priceAssetId58)
392
392
 
                        let priceAssetInfo = valueOrErrorMessage(assetInfo(priceAssetId), "fail to load price asset info")
393
393
 
                        let priceAssetMult = pow(10, 0, priceAssetInfo.decimals, 0, 0, DOWN)
394
394
 
                        let origTotalsArray = readTotalsArrayOrDefault()
395
395
 
                        let totalsDiff = [0, 0, 0, 0]
396
396
 
[StringEntry(keyConfig(), fromatConfig(idoStart, idoDuration, claimStart, claimDuration, price, priceMult, idoAssetId58, idoAssetMult, priceAssetId58, priceAssetMult, minInvestAmount, pmt.amount)), TotalsEntry(keyTotals(), origTotalsArray, totalsDiff, claimStart, 0)]
397
397
 
                        }
398
398
 
    }
399
399
 
400
400
 
401
401
 
402
402
 
@Callable(i)
403
403
 
func invest () = {
404
404
 
    let cfgArray = readConfigArray()
405
405
 
    let idoStart = parseIntValue(cfgArray[IdxCfgIdoStart])
406
406
 
    let idoDuration = parseIntValue(cfgArray[IdxCfgIdoDuration])
407
407
 
    let idoEnd = (idoStart + idoDuration)
408
408
 
    let claimStart = parseIntValue(cfgArray[IdxCfgClaimStart])
409
409
 
    let claimDuration = parseIntValue(cfgArray[IdxCfgClaimDuration])
410
410
 
    let price = parseIntValue(cfgArray[IdxCfgPrice])
411
411
 
    let priceMult = parseIntValue(cfgArray[IdxCfgPriceMult])
412
412
 
    let idoAssetId58 = cfgArray[IdxCfgIdoAssetId]
413
413
 
    let idoAssetId = fromBase58String(idoAssetId58)
414
414
 
    let idoAssetMult = parseIntValue(cfgArray[IdxCfgIdoAssetMult])
415
415
 
    let priceAssetId58 = cfgArray[IdxCfgPriceAssetId]
416
416
 
    let priceAssetId = fromBase58String(priceAssetId58)
417
417
 
    let priceAssetMult = parseIntValue(cfgArray[IdxCfgPriceAssetMult])
418
418
 
    let minIvestAmount = parseIntValue(cfgArray[IdxCfgMinInvestAmount])
419
419
 
    let userAddress = toString(i.caller)
420
420
 
    if ((idoStart > height))
421
421
 
        then throw("ido has not been started yet")
422
422
 
        else if ((height > idoEnd))
423
423
 
            then throw("ido has been already ended")
424
424
 
            else if ((size(i.payments) != 1))
425
425
 
                then throw("exactly 1 payment is expected")
426
426
 
                else {
427
427
 
                    let pmt = value(i.payments[0])
428
428
 
                    let pmtAssetId = value(pmt.assetId)
429
429
 
                    let pmtAmount = pmt.amount
430
430
 
                    if ((pmtAssetId != priceAssetId))
431
431
 
                        then throw((("invalid payment asset id: " + toBase58String(pmtAssetId)) + " is expected"))
432
432
 
                        else {
433
433
 
                            let origInvestorArray = readInvestorArrayOrDefault(userAddress)
434
434
 
                            let origTotalsArray = readTotalsArrayOrDefault()
435
435
 
                            let newPriceTotalAmount = (parseIntValue(origTotalsArray[IdxInvTotalAmount]) + pmtAmount)
436
436
 
                            let requiredIdoAssetAmount = (newPriceTotalAmount * 100)
437
437
 
                            if ((requiredIdoAssetAmount > assetBalance(this, idoAssetId)))
438
438
 
                                then throw("IDO asset has been - sold consider to use smaller payment")
439
439
 
                                else {
440
440
 
                                    let totalsDiff = [pmtAmount, pmtAmount, 0, 0]
441
441
 
[TotalsEntry(keyInvestor(userAddress), origInvestorArray, totalsDiff, claimStart, 0), TotalsEntry(keyTotals(), origTotalsArray, totalsDiff, claimStart, 0), InvestOperationHistoryEntry(userAddress, pmtAmount, 0, i.transactionId)]
442
442
 
                                    }
443
443
 
                            }
444
444
 
                    }
445
445
 
    }
446
446
 
447
447
 
448
448
 
449
449
 
@Callable(i)
450
450
 
func claim (claimedAssetId58,userAddress58) = {
451
451
 
    let callerAddress58 = toString(i.caller)
452
452
 
    if ((userAddress58 != callerAddress58))
453
453
 
        then throw("not authorized")
454
454
 
        else {
455
455
 
            let cfgArray = readConfigArray()
456
456
 
            let priceAssetId58 = cfgArray[IdxCfgPriceAssetId]
457
457
 
            let claimResultTuple = internalClaim(claimedAssetId58, i.caller, i.transactionId)
458
458
 
            let totalsDiff = claimResultTuple._1
459
459
 
            let outAmount = claimResultTuple._2
460
460
 
            let outAssetId = claimResultTuple._3
461
461
 
            let origInvestArray = claimResultTuple._4
462
462
 
            let newClaimPeriodHeight = claimResultTuple._5
463
463
 
            let claimedPriceAmountFromDiff = totalsDiff[IdxDiffClaimedPriceAmountIncrement]
464
464
 
            let claimedIdoAssetAmountFromDiff = totalsDiff[IdxDiffClaimedIdoAssetAmountIncrement]
465
465
 
            let priceAssetBalance = valueOrElse(getInteger(keyPriceAssetBalance(userAddress58)), 0)
466
466
 
            let priceAssetDecimals = value(assetInfo(fromBase58String(priceAssetId58))).decimals
467
467
 
            let entries = if ((claimedAssetId58 == priceAssetId58))
468
468
 
                then {
469
469
 
                    let $t02205422498 = internalClaimV2(priceAssetId58, userAddress58, outAmount, totalsDiff[IdxDiffClaimedPriceAmountIncrement])
470
470
 
                    let periodMinAvailableToClaim = $t02205422498._1
471
471
 
                    let periodTotalAvailableToClaim = $t02205422498._2
472
472
 
                    let periodUserAvailableToClaim = $t02205422498._3
473
473
 
                    let totalUserAvailableToClaim = $t02205422498._4
474
474
 
                    let usdtPriceAssetAllowableRatio = $t02205422498._5
475
475
 
                    let currentUsdtPriceAssetRatio = $t02205422498._6
476
476
 
                    let endPeriodBlocksLeft = $t02205422498._7
477
477
 
                    let updatedCurrentPeriod = $t02205422498._8
478
478
 
                    let periodStart = $t02205422498._9
479
479
 
                    let periodEnd = $t02205422498._10
480
480
 
                    let checks = [if ((periodUserAvailableToClaim > 0))
481
481
 
                        then true
482
482
 
                        else throwErr("unavailable to claim because user period allowance reached"), if ((periodTotalAvailableToClaim > 0))
483
483
 
                        then true
484
484
 
                        else throwErr("unavailable to claim because total period allowance reached"), if ((periodMinAvailableToClaim > 0))
485
485
 
                        then true
486
486
 
                        else throwErr("nothing to claim"), if ((usdtPriceAssetAllowableRatio > currentUsdtPriceAssetRatio))
487
487
 
                        then true
488
488
 
                        else throwErr("unavailable to claim because usdn price lower than usdtPriceAssetAllowableRatio")]
489
489
 
                    if ((checks == checks))
490
490
 
                        then {
491
491
 
                            let updatedPeriodTotalAvailableToClaim = (periodTotalAvailableToClaim - periodMinAvailableToClaim)
492
492
 
                            let updatedPeriodUserAvailableToClaim = (periodUserAvailableToClaim - periodMinAvailableToClaim)
493
493
 
                            let entries = if ((priceAssetBalance > periodMinAvailableToClaim))
494
494
 
                                then [ScriptTransfer(i.caller, periodMinAvailableToClaim, outAssetId), IntegerEntry(keyPriceAssetBalance(userAddress58), (priceAssetBalance - periodMinAvailableToClaim))]
495
495
 
                                else {
496
496
 
                                    let evaluateResult = split(asString(invoke(this, "claimREADONLY", [priceAssetId58, userAddress58], nil)), SEP)
497
497
 
                                    if ((evaluateResult == evaluateResult))
498
498
 
                                        then {
499
499
 
                                            let availablePriceAmountToClaim = parseIntValue(evaluateResult[3])
500
500
 
                                            let lastClaimEntries = if ((availablePriceAmountToClaim == periodMinAvailableToClaim))
501
501
 
                                                then {
502
502
 
                                                    let investorTotalAmount = parseIntValue(origInvestArray[IdxInvTotalAmount])
503
503
 
                                                    let investorRemainingAmount = parseIntValue(origInvestArray[IdxInvRemainingAmount])
504
504
 
                                                    let investorPriceAssetBalance = parseIntValue(origInvestArray[IdxInvClaimedPriceAssetAmount])
505
505
 
                                                    let investorIdoAssetBalance = parseIntValue(origInvestArray[IdxInvClaimedIdoAssetAmount])
506
506
 
                                                    let investorLastClaimedHeight = parseIntValue(origInvestArray[IdxInvLastClaimedHeight])
507
507
 
                                                    let newInvestArray = [toString(investorTotalAmount), "0", toString(investorPriceAssetBalance), toString(investorIdoAssetBalance), toString(investorLastClaimedHeight)]
508
508
 
                                                    let totals = readTotalsArrayOrDefault()
509
509
 
                                                    let totalsTotalAmount = parseIntValue(totals[IdxInvTotalAmount])
510
510
 
                                                    let totalsRemainingAmount = parseIntValue(totals[IdxInvRemainingAmount])
511
-
                                                    let totalsClaimedPriceAssetAmount = parseIntValue(totals[IdxInvRemainingAmount])
512
-
                                                    let totalsClaimedIdoAssetAmount = parseIntValue(totals[IdxInvClaimedPriceAssetAmount])
511
+
                                                    let totalsClaimedPriceAssetAmount = parseIntValue(totals[IdxInvClaimedPriceAssetAmount])
512
+
                                                    let totalsClaimedIdoAssetAmount = parseIntValue(totals[IdxInvClaimedIdoAssetAmount])
513
513
 
                                                    let totalsLastClaimedHeight = parseIntValue(totals[IdxInvLastClaimedHeight])
514
514
 
                                                    let newTotalsRemainingAmount = (totalsRemainingAmount - investorRemainingAmount)
515
515
 
                                                    let newTotalArray = [toString(totalsTotalAmount), toString(newTotalsRemainingAmount), toString(totalsClaimedPriceAssetAmount), toString(totalsClaimedIdoAssetAmount), toString(totalsLastClaimedHeight)]
516
516
 
                                                    let newTotalRemainingAmount = (valueOrElse(getInteger(keyTotalRemainingAmount()), 0) + investorRemainingAmount)
517
517
 
[StringEntry(keyInvestorRemainingAmount(userAddress58), toString(investorRemainingAmount)), StringEntry(keyTotalRemainingAmount(), toString(newTotalRemainingAmount)), TotalsEntry(keyInvestor(userAddress58), newInvestArray, totalsDiff, newClaimPeriodHeight, 0), TotalsEntry(keyTotals(), newTotalArray, totalsDiff, newClaimPeriodHeight, 0)]
518
518
 
                                                    }
519
519
 
                                                else [TotalsEntry(keyInvestor(userAddress58), origInvestArray, totalsDiff, newClaimPeriodHeight, 0), TotalsEntry(keyTotals(), readTotalsArrayOrDefault(), totalsDiff, newClaimPeriodHeight, 0)]
520
520
 
                                            let updatedPriceAssetBalance = ((priceAssetBalance + outAmount) - periodMinAvailableToClaim)
521
521
 
                                            ([ScriptTransfer(i.caller, periodMinAvailableToClaim, outAssetId), IntegerEntry(keyPriceAssetBalance(userAddress58), updatedPriceAssetBalance)] ++ lastClaimEntries)
522
522
 
                                            }
523
523
 
                                        else throw("Strict value is not equal to itself.")
524
524
 
                                    }
525
525
 
                            $Tuple2(([IntegerEntry(keyCurrentPeriod(), updatedCurrentPeriod), IntegerEntry(keyPeriodStartHeight(updatedCurrentPeriod), periodStart), IntegerEntry(keyPeriodEndHeight(updatedCurrentPeriod), periodEnd), IntegerEntry(keyPeriodTotalAvailableToClaim(priceAssetId58, updatedCurrentPeriod), updatedPeriodTotalAvailableToClaim), IntegerEntry(keyPeriodUserAvailableToClaim(priceAssetId58, updatedCurrentPeriod, userAddress58), updatedPeriodUserAvailableToClaim), ClaimOperationHistoryEntry(userAddress58, periodMinAvailableToClaim, claimedIdoAssetAmountFromDiff, i.transactionId)] ++ entries), unit)
526
526
 
                            }
527
527
 
                        else throw("Strict value is not equal to itself.")
528
528
 
                    }
529
529
 
                else {
530
530
 
                    let priceAssetBalanceIdoDecimals = fraction(priceAssetBalance, scale8, pow(10, 0, priceAssetDecimals, 0, 0, DOWN))
531
531
 
                    $Tuple2([ScriptTransfer(i.caller, (outAmount + priceAssetBalanceIdoDecimals), outAssetId), IntegerEntry(keyPriceAssetBalance(userAddress58), 0), TotalsEntry(keyInvestor(userAddress58), origInvestArray, totalsDiff, newClaimPeriodHeight, priceAssetBalance), TotalsEntry(keyTotals(), readTotalsArrayOrDefault(), totalsDiff, newClaimPeriodHeight, priceAssetBalance), ClaimOperationHistoryEntry(userAddress58, claimedPriceAmountFromDiff, (claimedIdoAssetAmountFromDiff + priceAssetBalanceIdoDecimals), i.transactionId)], unit)
532
532
 
                    }
533
533
 
            entries
534
534
 
            }
535
+
    }
536
+
537
+
538
+
539
+
@Callable(i)
540
+
func cleanRemaingAmount (userAddress58) = {
541
+
    let priceAssetId58 = readConfigArray()[IdxCfgPriceAssetId]
542
+
    let evaluateResult = split(asString(invoke(this, "claimREADONLY", [priceAssetId58, userAddress58], nil)), SEP)
543
+
    if ((evaluateResult == evaluateResult))
544
+
        then {
545
+
            let availablePriceAmountToClaim = parseIntValue(evaluateResult[2])
546
+
            let checkUnclaimedAssets = if ((availablePriceAmountToClaim == 0))
547
+
                then true
548
+
                else throwErr("user have unclaimed assets")
549
+
            if ((checkUnclaimedAssets == checkUnclaimedAssets))
550
+
                then {
551
+
                    let investor = split(value(getString(keyInvestor(userAddress58))), SEP)
552
+
                    let investorTotalAmount = parseIntValue(investor[IdxInvTotalAmount])
553
+
                    let investorRemainingAmount = parseIntValue(investor[IdxInvRemainingAmount])
554
+
                    let investorPriceAssetBalance = parseIntValue(investor[IdxInvClaimedPriceAssetAmount])
555
+
                    let investorIdoAssetBalance = parseIntValue(investor[IdxInvClaimedIdoAssetAmount])
556
+
                    let investorLastClaimedHeight = parseIntValue(investor[IdxInvLastClaimedHeight])
557
+
                    let investorRemainingAmountCheck = if ((investorRemainingAmount != 0))
558
+
                        then true
559
+
                        else throwErr("investorRemainingAmount already zero")
560
+
                    if ((investorRemainingAmountCheck == investorRemainingAmountCheck))
561
+
                        then {
562
+
                            let newInvestor = makeString(["%d%d%d%d%d", toString(investorTotalAmount), "0", toString(investorPriceAssetBalance), toString(investorIdoAssetBalance), toString(investorLastClaimedHeight)], SEP)
563
+
                            let totals = split(value(getString(keyTotals())), SEP)
564
+
                            let totalsTotalAmount = parseIntValue(totals[IdxInvTotalAmount])
565
+
                            let totalsRemainingAmount = parseIntValue(totals[IdxInvRemainingAmount])
566
+
                            let totalsClaimedPriceAssetAmount = parseIntValue(totals[IdxInvClaimedPriceAssetAmount])
567
+
                            let totalsClaimedIdoAssetAmount = parseIntValue(totals[IdxInvClaimedIdoAssetAmount])
568
+
                            let totalsLastClaimedHeight = parseIntValue(totals[IdxInvLastClaimedHeight])
569
+
                            let newTotals = makeString(["%d%d%d%d%d", toString(totalsTotalAmount), toString((totalsRemainingAmount - investorRemainingAmount)), toString(totalsClaimedPriceAssetAmount), toString(totalsClaimedIdoAssetAmount), toString(totalsLastClaimedHeight)], SEP)
570
+
                            let newTotalRemainingAmount = (valueOrElse(getInteger(keyTotalRemainingAmount()), 0) + investorRemainingAmount)
571
+
[StringEntry(keyInvestorRemainingAmount(userAddress58), toString(investorRemainingAmount)), StringEntry(keyTotalRemainingAmount(), toString(newTotalRemainingAmount)), StringEntry(keyInvestor(userAddress58), newInvestor), StringEntry(keyTotals(), newTotals)]
572
+
                            }
573
+
                        else throw("Strict value is not equal to itself.")
574
+
                    }
575
+
                else throw("Strict value is not equal to itself.")
576
+
            }
577
+
        else throw("Strict value is not equal to itself.")
535
578
 
    }
536
579
 
537
580
 
538
581
 
539
582
 
@Callable(i)
540
583
 
func claimREADONLY (claimedAssetId58,userAddress58) = {
541
584
 
    let claimResultTuple = internalClaim(claimedAssetId58, addressFromStringValue(userAddress58), fromBase58String(""))
542
585
 
    let totalsDiff = claimResultTuple._1
543
586
 
    let outAmount = claimResultTuple._2
544
587
 
    let outAssetId = claimResultTuple._3
545
588
 
    let origInvestArray = claimResultTuple._4
546
589
 
    let newClaimPeriodHeight = claimResultTuple._5
547
590
 
    let availableToClaimArray = claimResultTuple._6
548
591
 
    let availablePriceAmountToClaim = availableToClaimArray[0]
549
592
 
    let availableIdoAmountToClaim = availableToClaimArray[1]
550
593
 
    $Tuple2(nil, makeString(["%s%d%d", userAddress58, toString(availablePriceAmountToClaim), toString(availableIdoAmountToClaim)], SEP))
551
594
 
    }
552
595
 
553
596
 
554
597
 
555
598
 
@Callable(i)
556
599
 
func claimV2READONLY (claimedAssetId58,userAddress58) = {
557
600
 
    let claimResultTuple = internalClaim(claimedAssetId58, addressFromStringValue(userAddress58), fromBase58String(""))
558
601
 
    let totalsDiff = claimResultTuple._1
559
602
 
    let outAmount = claimResultTuple._2
560
603
 
    let outAssetId = claimResultTuple._3
561
604
 
    let origInvestArray = claimResultTuple._4
562
605
 
    let newClaimPeriodHeight = claimResultTuple._5
563
606
 
    let availableToClaimArray = claimResultTuple._6
564
607
 
    let availablePriceAmountToClaim = availableToClaimArray[0]
565
608
 
    let availableIdoAmountToClaim = availableToClaimArray[1]
566
609
 
    let cfgArray = readConfigArray()
567
610
 
    let priceAssetId58 = cfgArray[IdxCfgPriceAssetId]
568
611
 
    let priceAssetBalance = valueOrElse(getInteger(keyPriceAssetBalance(userAddress58)), 0)
569
612
 
    let priceAssetBalanceIdoDecimals = (priceAssetBalance * 100)
570
613
 
    let availableIdoAmountToClaimWithPriceAssetBalance = (availableIdoAmountToClaim + priceAssetBalanceIdoDecimals)
571
-
    let $t03128231694 = internalClaimV2(priceAssetId58, userAddress58, outAmount, totalsDiff[IdxDiffClaimedPriceAmountIncrement])
572
-
    let periodMinAvailableToClaim = $t03128231694._1
573
-
    let periodTotalAvailableToClaim = $t03128231694._2
574
-
    let periodUserAvailableToClaim = $t03128231694._3
575
-
    let totalUserAvailableToClaim = $t03128231694._4
576
-
    let usdtPriceAssetAllowableRatio = $t03128231694._5
577
-
    let currentUsdtPriceAssetRatio = $t03128231694._6
578
-
    let endPeriodBlocksLeft = $t03128231694._7
579
-
    let updatedCurrentPeriod = $t03128231694._8
580
-
    let periodStart = $t03128231694._9
581
-
    let periodEnd = $t03128231694._10
614
+
    let $t03374934161 = internalClaimV2(priceAssetId58, userAddress58, outAmount, totalsDiff[IdxDiffClaimedPriceAmountIncrement])
615
+
    let periodMinAvailableToClaim = $t03374934161._1
616
+
    let periodTotalAvailableToClaim = $t03374934161._2
617
+
    let periodUserAvailableToClaim = $t03374934161._3
618
+
    let totalUserAvailableToClaim = $t03374934161._4
619
+
    let usdtPriceAssetAllowableRatio = $t03374934161._5
620
+
    let currentUsdtPriceAssetRatio = $t03374934161._6
621
+
    let endPeriodBlocksLeft = $t03374934161._7
622
+
    let updatedCurrentPeriod = $t03374934161._8
623
+
    let periodStart = $t03374934161._9
624
+
    let periodEnd = $t03374934161._10
582
625
 
    let currentPeriodEndHeight = valueOrElse(getInteger(keyPeriodEndHeight(updatedCurrentPeriod)), 0)
583
626
 
    let userTotalPriceAssetClaimed = (parseIntValue(readInvestorArrayOrFail(userAddress58)[IdxInvClaimedPriceAssetAmount]) - priceAssetBalance)
584
627
 
    let resultString = if ((height > currentPeriodEndHeight))
585
628
 
        then {
586
629
 
            let periodLenght = value(getInteger(keyPeriodLength()))
587
630
 
            let userPeriodAllowance = value(getInteger(keyUserPeriodAllowance(priceAssetId58)))
588
631
 
            let totalPeriodAllowance = value(getInteger(keyTotalPeriodAllowance(priceAssetId58)))
589
632
 
            makeString(["%d%d%d%d%d%d", toString(availableIdoAmountToClaimWithPriceAssetBalance), toString(userPeriodAllowance), toString(totalPeriodAllowance), toString(usdtPriceAssetAllowableRatio), toString(currentUsdtPriceAssetRatio), toString(periodLenght), toString(userTotalPriceAssetClaimed)], SEP)
590
633
 
            }
591
634
 
        else makeString(["%d%d%d%d%d%d", toString(availableIdoAmountToClaimWithPriceAssetBalance), toString(periodMinAvailableToClaim), toString(periodTotalAvailableToClaim), toString(usdtPriceAssetAllowableRatio), toString(currentUsdtPriceAssetRatio), toString(endPeriodBlocksLeft), toString(userTotalPriceAssetClaimed)], SEP)
592
635
 
    $Tuple2(nil, resultString)
593
636
 
    }
594
637
 
595
638
 
596
639
 
597
640
 
@Callable(i)
598
641
 
func setManager (pendingManagerPublicKey) = {
599
642
 
    let checkCaller = mustManager(i)
600
643
 
    if ((checkCaller == checkCaller))
601
644
 
        then {
602
645
 
            let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
603
646
 
            if ((checkManagerPublicKey == checkManagerPublicKey))
604
647
 
                then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
605
648
 
                else throw("Strict value is not equal to itself.")
606
649
 
            }
607
650
 
        else throw("Strict value is not equal to itself.")
608
651
 
    }
609
652
 
610
653
 
611
654
 
612
655
 
@Callable(i)
613
656
 
func confirmManager () = {
614
657
 
    let pm = pendingManagerPublicKeyOrUnit()
615
658
 
    let hasPM = if (isDefined(pm))
616
659
 
        then true
617
660
 
        else throw("No pending manager")
618
661
 
    if ((hasPM == hasPM))
619
662
 
        then {
620
663
 
            let checkPM = if ((i.callerPublicKey == value(pm)))
621
664
 
                then true
622
665
 
                else throw("You are not pending manager")
623
666
 
            if ((checkPM == checkPM))
624
667
 
                then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
625
668
 
                else throw("Strict value is not equal to itself.")
626
669
 
            }
627
670
 
        else throw("Strict value is not equal to itself.")
628
671
 
    }
629
672
 
630
673
 
631
674
 
@Verifier(tx)
632
675
 
func verify () = {
633
676
 
    let targetPublicKey =     match managerPublicKeyOrUnit() {
634
677
 
        case pk: ByteVector => 
635
678
 
            pk
636
679
 
        case _: Unit => 
637
680
 
            tx.senderPublicKey
638
681
 
        case _ => 
639
682
 
            throw("Match error")
640
683
 
    }
641
684
 
    sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
642
685
 
    }
643
686
 

github/deemru/w8io/786bc32 
70.39 ms ◑