tx · Eav31zkrUGEnpbGEEGBSVks1QwMtRLDaPsqX1PcZ9Krr

3NAsFvuLwxz1iUtZ9fmhfmSN16r9NEsPqsh:  -0.01600000 Waves

2022.07.28 19:07 [2159895] smart account 3NAsFvuLwxz1iUtZ9fmhfmSN16r9NEsPqsh > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "Eav31zkrUGEnpbGEEGBSVks1QwMtRLDaPsqX1PcZ9Krr",
    "fee": 1600000,
    "feeAssetId": null,
    "timestamp": 1659024428955,
    "version": 1,
    "sender": "3NAsFvuLwxz1iUtZ9fmhfmSN16r9NEsPqsh",
    "senderPublicKey": "33fpjdpM9FMu87RZKePniPardKqQXM96sm7VhAk3JEVQ",
    "proofs": [
        "3nX7yvwzMJuv19Pt3Y6KCRyYfNde42tMK8kF2mLmq32uxWKvjX1J59Tp9yTc7F6Kj3hn4D916pCr9qtLc8tDTZ3f"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2159895,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 6UaxptDcpLKYeS3ANnaxmm5AApe4uiXSXtwetCnTbXmL
Next: 3YzZr6vnD6D7LZ1t4ih11zb7Q8h7BMZRAea5C9Rs68PJ

Diff: 
Old
New
Differences
48
48
 
49
49
 
50
50
 
func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
51
+
52
+
53
+
func keyClaimHistory (programName,userAddress,transactionId) = makeString(["%s%s%s%s%s", "history", "claim", programName, userAddress, transactionId], separator)
54
+
55
+
56
+
func formatClaimHistory (amount) = makeString(["%d%d%d", toString(lastBlock.height), toString(lastBlock.timestamp), toString(amount)], separator)
51
57
 
52
58
 
53
59
 
func throwErr (msg) = throw(makeString(["referral.ride:", msg], " "))
222
228
 
        else throwErr("program does not exist")
223
229
 
    if ((checkProgramExists == checkProgramExists))
224
230
 
        then {
231
+
            let userAddressStr = toString(i.caller)
225
232
 
            let claimedTotal = valueOrElse(getInteger(keyClaimedTotal(programName)), 0)
226
-
            let claimerClaimed = valueOrElse(getInteger(keyClaimed(programName, toString(i.caller))), 0)
227
-
            let claimerUnclaimed = valueOrElse(getInteger(keyUnclaimed(programName, toString(i.caller))), 0)
233
+
            let claimerClaimed = valueOrElse(getInteger(keyClaimed(programName, userAddressStr)), 0)
234
+
            let claimerUnclaimed = valueOrElse(getInteger(keyUnclaimed(programName, userAddressStr)), 0)
228
235
 
            let treasuryContract = value(addressFromString(value(getString(keyTreasuryContract(programName)))))
229
236
 
            let rewardAssetId = fromBase58String(value(getString(keyRewardAssetId(programName))))
230
237
 
            let checkCanClaim = if ((claimerUnclaimed > 0))
250
257
 
                                                        then true
251
258
 
                                                        else throwErr("insufficient balance on referral contract")
252
259
 
                                                    if ((checkBalance == checkBalance))
253
-
                                                        then $Tuple2([IntegerEntry(keyClaimed(programName, toString(i.caller)), newClaimerClaimed), IntegerEntry(keyClaimedTotal(programName), newClaimedTotal), IntegerEntry(keyUnclaimed(programName, toString(i.caller)), 0), ScriptTransfer(i.caller, claimerUnclaimed, rewardAssetId)], unit)
260
+
                                                        then $Tuple2([IntegerEntry(keyClaimed(programName, userAddressStr), newClaimerClaimed), IntegerEntry(keyClaimedTotal(programName), newClaimedTotal), IntegerEntry(keyUnclaimed(programName, userAddressStr), 0), ScriptTransfer(i.caller, claimerUnclaimed, rewardAssetId), StringEntry(keyClaimHistory(programName, userAddressStr, toBase58String(i.transactionId)), formatClaimHistory(claimerUnclaimed))], unit)
254
261
 
                                                        else throw("Strict value is not equal to itself.")
255
262
 
                                                    }
256
263
 
                                                else throw("Strict value is not equal to itself.")
Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 6 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
let separator = "__"
5
5
 
6
6
 
let keyBackendPublicKey = makeString(["%s", "backendPublicKey"], separator)
7
7
 
8
8
 
func keyExistsReferrerToReferral (programName,referrerAddress,referralAddress) = makeString(["%s%s%s%s", "existsReferrerToReferral", programName, referrerAddress, referralAddress], separator)
9
9
 
10
10
 
11
11
 
func keyClaimed (programName,claimerAddress) = makeString(["%s%s%s%s", "claimed", programName, claimerAddress], separator)
12
12
 
13
13
 
14
14
 
func keyUnclaimed (programName,claimerAddress) = makeString(["%s%s%s%s", "unclaimed", programName, claimerAddress], separator)
15
15
 
16
16
 
17
17
 
func keyReferrer (programName,referralAddress) = makeString(["%s%s%s", "referrer", programName, referralAddress], separator)
18
18
 
19
19
 
20
20
 
func keyProgramName (programName) = makeString(["%s%s", "programName", programName], separator)
21
21
 
22
22
 
23
23
 
func keyTotalReferralCount (programName,referrerAddress) = makeString(["%s%s%s", "totalReferralCount", programName, referrerAddress], separator)
24
24
 
25
25
 
26
26
 
func keyActiveReferralCount (programName,referrerAddress) = makeString(["%s%s%s", "activeReferralCount", programName, referrerAddress], separator)
27
27
 
28
28
 
29
29
 
func keyIsReferralActive (programName,referralAddress) = makeString(["%s%s%s", "activeReferral", programName, referralAddress], separator)
30
30
 
31
31
 
32
32
 
func keyClaimedTotal (programName) = makeString(["%s%s", "claimedTotal", programName], separator)
33
33
 
34
34
 
35
35
 
func keyRewardsTotal (programName) = makeString(["%s%s", "rewardsTotal", programName], separator)
36
36
 
37
37
 
38
38
 
func keyRewardAssetId (programName) = makeString(["%s%s", "rewardAssetId", programName], separator)
39
39
 
40
40
 
41
41
 
func keyTreasuryContract (programName) = makeString(["%s%s", "treasuryContract", programName], separator)
42
42
 
43
43
 
44
44
 
func keyImplementationContract (programName) = makeString(["%s%s", "implementationContract", programName], separator)
45
45
 
46
46
 
47
47
 
func keyManagerPublicKey () = "%s__managerPublicKey"
48
48
 
49
49
 
50
50
 
func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
51
+
52
+
53
+
func keyClaimHistory (programName,userAddress,transactionId) = makeString(["%s%s%s%s%s", "history", "claim", programName, userAddress, transactionId], separator)
54
+
55
+
56
+
func formatClaimHistory (amount) = makeString(["%d%d%d", toString(lastBlock.height), toString(lastBlock.timestamp), toString(amount)], separator)
51
57
 
52
58
 
53
59
 
func throwErr (msg) = throw(makeString(["referral.ride:", msg], " "))
54
60
 
55
61
 
56
62
 
func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
57
63
 
    case s: String => 
58
64
 
        fromBase58String(s)
59
65
 
    case _: Unit => 
60
66
 
        unit
61
67
 
    case _ => 
62
68
 
        throw("Match error")
63
69
 
}
64
70
 
65
71
 
66
72
 
func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
67
73
 
    case s: String => 
68
74
 
        fromBase58String(s)
69
75
 
    case _: Unit => 
70
76
 
        unit
71
77
 
    case _ => 
72
78
 
        throw("Match error")
73
79
 
}
74
80
 
75
81
 
76
82
 
func mustManager (i) = {
77
83
 
    let pd = throwErr("permission denied")
78
84
 
    match managerPublicKeyOrUnit() {
79
85
 
        case pk: ByteVector => 
80
86
 
            if ((i.callerPublicKey == pk))
81
87
 
                then true
82
88
 
                else pd
83
89
 
        case _: Unit => 
84
90
 
            if ((i.caller == this))
85
91
 
                then true
86
92
 
                else pd
87
93
 
        case _ => 
88
94
 
            throw("Match error")
89
95
 
    }
90
96
 
    }
91
97
 
92
98
 
93
99
 
@Callable(i)
94
100
 
func createReferralProgram (programName,treasuryContract,implementationContract,rewardAssetId) = {
95
101
 
    let checkCaller = mustManager(i)
96
102
 
    if ((checkCaller == checkCaller))
97
103
 
        then {
98
104
 
            let checkProgramName = if ((getBoolean(keyProgramName(programName)) == unit))
99
105
 
                then true
100
106
 
                else throwErr("program name already exists")
101
107
 
            if ((checkProgramName == checkProgramName))
102
108
 
                then {
103
109
 
                    let programNameIsValid = if (!(contains(programName, separator)))
104
110
 
                        then !(contains(programName, " "))
105
111
 
                        else false
106
112
 
                    let checkProgramExists = if (programNameIsValid)
107
113
 
                        then true
108
114
 
                        else throwErr("invalid program name")
109
115
 
                    if ((checkProgramExists == checkProgramExists))
110
116
 
                        then {
111
117
 
                            let checkRewardAsset = if ((assetInfo(fromBase58String(rewardAssetId)) != unit))
112
118
 
                                then true
113
119
 
                                else throwErr("invalid reward asset id")
114
120
 
                            if ((checkRewardAsset == checkRewardAsset))
115
121
 
                                then $Tuple2([BooleanEntry(keyProgramName(programName), true), StringEntry(keyTreasuryContract(programName), treasuryContract), StringEntry(keyImplementationContract(programName), implementationContract), StringEntry(keyRewardAssetId(programName), rewardAssetId), IntegerEntry(keyRewardsTotal(programName), 0)], unit)
116
122
 
                                else throw("Strict value is not equal to itself.")
117
123
 
                            }
118
124
 
                        else throw("Strict value is not equal to itself.")
119
125
 
                    }
120
126
 
                else throw("Strict value is not equal to itself.")
121
127
 
            }
122
128
 
        else throw("Strict value is not equal to itself.")
123
129
 
    }
124
130
 
125
131
 
126
132
 
127
133
 
@Callable(i)
128
134
 
func createPair (programName,referrerAddress,referralAddress,signature) = {
129
135
 
    let checkProgramExists = if (valueOrElse(getBoolean(keyProgramName(programName)), false))
130
136
 
        then true
131
137
 
        else throwErr("program does not exist")
132
138
 
    if ((checkProgramExists == checkProgramExists))
133
139
 
        then {
134
140
 
            let pairReferrerToReferralExistCheck = if ((getString(keyExistsReferrerToReferral(programName, referrerAddress, referralAddress)) == unit))
135
141
 
                then true
136
142
 
                else throwErr("pair already exists")
137
143
 
            if ((pairReferrerToReferralExistCheck == pairReferrerToReferralExistCheck))
138
144
 
                then {
139
145
 
                    let noRefSelf = if ((referrerAddress != referralAddress))
140
146
 
                        then true
141
147
 
                        else throwErr("cannot refer to self")
142
148
 
                    if ((noRefSelf == noRefSelf))
143
149
 
                        then {
144
150
 
                            let pair = toBytes(makeString([programName, referrerAddress, referralAddress], ":"))
145
151
 
                            let backendPublicKey = fromBase58String(value(getString(keyBackendPublicKey)))
146
152
 
                            let validateSignature = if (sigVerify(pair, signature, backendPublicKey))
147
153
 
                                then true
148
154
 
                                else throwErr("bad signature")
149
155
 
                            if ((validateSignature == validateSignature))
150
156
 
                                then {
151
157
 
                                    let totalReferralCount = valueOrElse(getInteger(keyTotalReferralCount(programName, referrerAddress)), 0)
152
158
 
                                    let newTotalReferralCount = (totalReferralCount + 1)
153
159
 
                                    $Tuple2([BooleanEntry(keyExistsReferrerToReferral(programName, referrerAddress, referralAddress), true), IntegerEntry(keyTotalReferralCount(programName, referrerAddress), newTotalReferralCount), StringEntry(keyReferrer(programName, referralAddress), referrerAddress)], unit)
154
160
 
                                    }
155
161
 
                                else throw("Strict value is not equal to itself.")
156
162
 
                            }
157
163
 
                        else throw("Strict value is not equal to itself.")
158
164
 
                    }
159
165
 
                else throw("Strict value is not equal to itself.")
160
166
 
            }
161
167
 
        else throw("Strict value is not equal to itself.")
162
168
 
    }
163
169
 
164
170
 
165
171
 
166
172
 
@Callable(i)
167
173
 
func updateReferralActivity (programName,referralAddress,isActive) = {
168
174
 
    let implementationContract = value(getString(keyImplementationContract(programName)))
169
175
 
    let isReferralActive = (getBoolean(keyIsReferralActive(programName, referralAddress)) != unit)
170
176
 
    let referrerAddress = value(getString(keyReferrer(programName, referralAddress)))
171
177
 
    let checkCaller = if ((toString(i.caller) == implementationContract))
172
178
 
        then true
173
179
 
        else throwErr("permission denied")
174
180
 
    if ((checkCaller == checkCaller))
175
181
 
        then {
176
182
 
            let update = if ((isReferralActive == isActive))
177
183
 
                then $Tuple2(nil, unit)
178
184
 
                else {
179
185
 
                    let update = if ((isActive == true))
180
186
 
                        then {
181
187
 
                            let newActiveReferralCount = (valueOrElse(getInteger(keyActiveReferralCount(programName, referrerAddress)), 0) + 1)
182
188
 
                            $Tuple2([BooleanEntry(keyIsReferralActive(programName, referralAddress), true), IntegerEntry(keyActiveReferralCount(programName, referrerAddress), newActiveReferralCount)], unit)
183
189
 
                            }
184
190
 
                        else {
185
191
 
                            let newActiveReferralCount = (valueOrElse(getInteger(keyActiveReferralCount(programName, referrerAddress)), 0) - 1)
186
192
 
                            $Tuple2([DeleteEntry(keyIsReferralActive(programName, referralAddress)), IntegerEntry(keyActiveReferralCount(programName, referrerAddress), newActiveReferralCount)], unit)
187
193
 
                            }
188
194
 
                    update
189
195
 
                    }
190
196
 
            update
191
197
 
            }
192
198
 
        else throw("Strict value is not equal to itself.")
193
199
 
    }
194
200
 
195
201
 
196
202
 
197
203
 
@Callable(i)
198
204
 
func incUnclaimed (programName,referralAddress,referrerReward,referralReward) = {
199
205
 
    let implementationContract = value(getString(keyImplementationContract(programName)))
200
206
 
    let checkCaller = if ((toString(i.caller) == implementationContract))
201
207
 
        then true
202
208
 
        else throwErr("permission denied")
203
209
 
    if ((checkCaller == checkCaller))
204
210
 
        then {
205
211
 
            let referrerAddress = value(getString(keyReferrer(programName, referralAddress)))
206
212
 
            let referrerUnclaimed = valueOrElse(getInteger(keyUnclaimed(programName, referrerAddress)), 0)
207
213
 
            let referralUnclaimed = valueOrElse(getInteger(keyUnclaimed(programName, referralAddress)), 0)
208
214
 
            let rewardsTotal = valueOrElse(getInteger(keyRewardsTotal(programName)), 0)
209
215
 
            let newReferrerUnclaimed = (referrerUnclaimed + referrerReward)
210
216
 
            let newReferralUnclaimed = (referralUnclaimed + referralReward)
211
217
 
            $Tuple2([IntegerEntry(keyUnclaimed(programName, referrerAddress), newReferrerUnclaimed), IntegerEntry(keyUnclaimed(programName, referralAddress), newReferralUnclaimed), IntegerEntry(keyRewardsTotal(programName), ((rewardsTotal + referrerReward) + referralReward))], unit)
212
218
 
            }
213
219
 
        else throw("Strict value is not equal to itself.")
214
220
 
    }
215
221
 
216
222
 
217
223
 
218
224
 
@Callable(i)
219
225
 
func claim (programName) = {
220
226
 
    let checkProgramExists = if (valueOrElse(getBoolean(keyProgramName(programName)), false))
221
227
 
        then true
222
228
 
        else throwErr("program does not exist")
223
229
 
    if ((checkProgramExists == checkProgramExists))
224
230
 
        then {
231
+
            let userAddressStr = toString(i.caller)
225
232
 
            let claimedTotal = valueOrElse(getInteger(keyClaimedTotal(programName)), 0)
226
-
            let claimerClaimed = valueOrElse(getInteger(keyClaimed(programName, toString(i.caller))), 0)
227
-
            let claimerUnclaimed = valueOrElse(getInteger(keyUnclaimed(programName, toString(i.caller))), 0)
233
+
            let claimerClaimed = valueOrElse(getInteger(keyClaimed(programName, userAddressStr)), 0)
234
+
            let claimerUnclaimed = valueOrElse(getInteger(keyUnclaimed(programName, userAddressStr)), 0)
228
235
 
            let treasuryContract = value(addressFromString(value(getString(keyTreasuryContract(programName)))))
229
236
 
            let rewardAssetId = fromBase58String(value(getString(keyRewardAssetId(programName))))
230
237
 
            let checkCanClaim = if ((claimerUnclaimed > 0))
231
238
 
                then true
232
239
 
                else throwErr("nothing to claim")
233
240
 
            if ((checkCanClaim == checkCanClaim))
234
241
 
                then {
235
242
 
                    let newClaimerClaimed = (claimerClaimed + claimerUnclaimed)
236
243
 
                    let newClaimedTotal = (claimedTotal + claimerUnclaimed)
237
244
 
                    let balanceBefore = value(assetBalance(this, rewardAssetId))
238
245
 
                    if ((balanceBefore == balanceBefore))
239
246
 
                        then {
240
247
 
                            let res = invoke(treasuryContract, "withdrawReferralReward", [claimerUnclaimed], nil)
241
248
 
                            if ((res == res))
242
249
 
                                then {
243
250
 
                                    let balanceAfter = value(assetBalance(this, rewardAssetId))
244
251
 
                                    if ((balanceAfter == balanceAfter))
245
252
 
                                        then {
246
253
 
                                            let balanceDiff = (balanceAfter - balanceBefore)
247
254
 
                                            if ((balanceDiff == balanceDiff))
248
255
 
                                                then {
249
256
 
                                                    let checkBalance = if ((balanceDiff == claimerUnclaimed))
250
257
 
                                                        then true
251
258
 
                                                        else throwErr("insufficient balance on referral contract")
252
259
 
                                                    if ((checkBalance == checkBalance))
253
-
                                                        then $Tuple2([IntegerEntry(keyClaimed(programName, toString(i.caller)), newClaimerClaimed), IntegerEntry(keyClaimedTotal(programName), newClaimedTotal), IntegerEntry(keyUnclaimed(programName, toString(i.caller)), 0), ScriptTransfer(i.caller, claimerUnclaimed, rewardAssetId)], unit)
260
+
                                                        then $Tuple2([IntegerEntry(keyClaimed(programName, userAddressStr), newClaimerClaimed), IntegerEntry(keyClaimedTotal(programName), newClaimedTotal), IntegerEntry(keyUnclaimed(programName, userAddressStr), 0), ScriptTransfer(i.caller, claimerUnclaimed, rewardAssetId), StringEntry(keyClaimHistory(programName, userAddressStr, toBase58String(i.transactionId)), formatClaimHistory(claimerUnclaimed))], unit)
254
261
 
                                                        else throw("Strict value is not equal to itself.")
255
262
 
                                                    }
256
263
 
                                                else throw("Strict value is not equal to itself.")
257
264
 
                                            }
258
265
 
                                        else throw("Strict value is not equal to itself.")
259
266
 
                                    }
260
267
 
                                else throw("Strict value is not equal to itself.")
261
268
 
                            }
262
269
 
                        else throw("Strict value is not equal to itself.")
263
270
 
                    }
264
271
 
                else throw("Strict value is not equal to itself.")
265
272
 
            }
266
273
 
        else throw("Strict value is not equal to itself.")
267
274
 
    }
268
275
 
269
276
 
270
277
 
271
278
 
@Callable(i)
272
279
 
func claimREADONLY (programName,userAddress) = {
273
280
 
    let claimerClaimed = valueOrElse(getInteger(keyClaimed(programName, userAddress)), 0)
274
281
 
    let claimerUnclaimed = valueOrElse(getInteger(keyUnclaimed(programName, userAddress)), 0)
275
282
 
    $Tuple2(nil, [claimerUnclaimed, claimerClaimed])
276
283
 
    }
277
284
 
278
285
 
279
286
 
280
287
 
@Callable(i)
281
288
 
func setManager (pendingManagerPublicKey) = {
282
289
 
    let checkCaller = mustManager(i)
283
290
 
    if ((checkCaller == checkCaller))
284
291
 
        then {
285
292
 
            let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
286
293
 
            if ((checkManagerPublicKey == checkManagerPublicKey))
287
294
 
                then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
288
295
 
                else throw("Strict value is not equal to itself.")
289
296
 
            }
290
297
 
        else throw("Strict value is not equal to itself.")
291
298
 
    }
292
299
 
293
300
 
294
301
 
295
302
 
@Callable(i)
296
303
 
func confirmManager () = {
297
304
 
    let pm = pendingManagerPublicKeyOrUnit()
298
305
 
    let hasPM = if (isDefined(pm))
299
306
 
        then true
300
307
 
        else throwErr("no pending manager")
301
308
 
    if ((hasPM == hasPM))
302
309
 
        then {
303
310
 
            let checkPM = if ((i.callerPublicKey == value(pm)))
304
311
 
                then true
305
312
 
                else throwErr("you are not pending manager")
306
313
 
            if ((checkPM == checkPM))
307
314
 
                then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
308
315
 
                else throw("Strict value is not equal to itself.")
309
316
 
            }
310
317
 
        else throw("Strict value is not equal to itself.")
311
318
 
    }
312
319
 
313
320
 
314
321
 
@Verifier(tx)
315
322
 
func verify () = {
316
323
 
    let targetPublicKey =     match managerPublicKeyOrUnit() {
317
324
 
        case pk: ByteVector => 
318
325
 
            pk
319
326
 
        case _: Unit => 
320
327
 
            tx.senderPublicKey
321
328
 
        case _ => 
322
329
 
            throw("Match error")
323
330
 
    }
324
331
 
    sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
325
332
 
    }
326
333
 

github/deemru/w8io/873ac7e 
71.89 ms ◑