tx · bx8j9kHEUKB2HVhqNxG9FxhSovXrmLBCngAhrMF4qjc

3MvebeGZYw4DzztAuqcdxyT22s6rB3yMNj7:  -0.01000000 Waves

2022.03.16 21:37 [1966874] smart account 3MvebeGZYw4DzztAuqcdxyT22s6rB3yMNj7 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "bx8j9kHEUKB2HVhqNxG9FxhSovXrmLBCngAhrMF4qjc",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1647455634279,
    "version": 2,
    "chainId": 84,
    "sender": "3MvebeGZYw4DzztAuqcdxyT22s6rB3yMNj7",
    "senderPublicKey": "J283pC8bzRfJ3j1oxPrgDH8hjUVhFZS2CiRcPTmzQukz",
    "proofs": [
        "48Ge1WvHVMbKXbVw1D3PBbnf9mxDemiYrMEPsdQi6ZH4XfVDM3NUa3FvZ5z5yPCZDGjVwXLbTbaEUhGbLzDVTbUL"
    ],
    "script": "base64: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",
    "height": 1966874,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 44CX2X8qrFLSWUnJfyuia4Zeju9FynME48hBGLXkxb6s
Next: BoaeGAyH5JDHXHUH7Q5jXH9yiHSmtiUMMd7HuuLswh5g

Diff: 
Old
New
Differences
45
45
 
    }
46
46
 
47
47
 
48
+
func getCurrentBlock () = {
49
+
    let block =     match blockInfoByHeight(height) {
50
+
        case x: BlockInfo => 
51
+
            x
52
+
        case _ => 
53
+
            throw("Alla ricerca del blocco corrente: Blocco non trovato!")
54
+
    }
55
+
    block
56
+
    }
57
+
58
+
48
59
 
func getTimestamp () = {
49
60
 
    let block =     match blockInfoByHeight(height) {
50
61
 
        case x: BlockInfo => 
56
67
 
    }
57
68
 
58
69
 
59
-
func getVrf () = {
60
-
    let block =     match blockInfoByHeight(height) {
61
-
        case x: BlockInfo => 
62
-
            match x.vrf {
63
-
                case t: ByteVector => 
64
-
                    t
65
-
                case _ => 
66
-
                    throw("Alla ricerca del `vrf`: Blocco non trovato!")
67
-
            }
70
+
func getVrf (thisBlock) = {
71
+
    let vrf =     match thisBlock.vrf {
72
+
        case t: ByteVector => 
73
+
            t
68
74
 
        case _ => 
69
-
            throw("Alla ricerca del `vrf`: Blocco non trovato!")
75
+
            throw("Alla ricerca del `vrf`: Blocco non trovato o blocco non in versione 5 ritenta.")
70
76
 
    }
71
-
    block
77
+
    vrf
72
78
 
    }
73
79
 
74
80
 
75
81
 
func randomizer (inv) = {
76
-
    let rand = (((((getVrf() + inv.transactionId) + inv.callerPublicKey) + lastBlock.generationSignature) + toBytes(lastBlock.timestamp)) + toBytes(lastBlock.height))
82
+
    let currentBlock = getCurrentBlock()
83
+
    let rand = (((((inv.transactionId + inv.callerPublicKey) + getVrf(currentBlock)) + currentBlock.generationSignature) + toBytes(currentBlock.timestamp)) + toBytes(currentBlock.height))
77
84
 
    sha256_16Kb(sha256_16Kb(rand))
78
85
 
    }
79
86
 
121
128
 
                        case _ => 
122
129
 
                            throw("Blocco non in versione 5 ritenta.")
123
130
 
                    }
124
-
                    let rand = (((seed + bloccoCandidato.generationSignature) + bloccoCandidato.generatorPublicKey) + vrfValue)
131
+
                    let rand = (((seed + bloccoCandidato.generationSignature) + bloccoCandidato.generatorPublicKey) + getVrf(bloccoCandidato))
125
132
 
                    let sha = toBase16String(sha256_16Kb(sha256_16Kb(rand)))
126
133
 
                    let strCardinalita = toString(myGetInt((keyPrefixN + fieldNameCardinalita), "Errore lettura cardinalità"))
127
134
 
                    let strDataRichiesta = toString(myGetInt((keyPrefixN + fieldNameDataRichiesta), "Errore lettura DataRichiesta"))
149
156
 
    let seed = randomizer(i)
150
157
 
    let currDate = getTimestamp()
151
158
 
    let heightExtraction = (height + delayBlock)
152
-
[IntegerEntry(keyCounter, nRichiesta), StringEntry((keyPrefixN + fieldNameSeedB16), toBase16String(seed)), BinaryEntry((keyPrefixN + fieldNameSeed), seed), StringEntry("test_vrf", toBase58String(getVrf())), IntegerEntry((keyPrefixN + fieldNameHeightExtraction), heightExtraction), IntegerEntry((keyPrefixN + fieldNameCardinalita), cardinalita), IntegerEntry((keyPrefixN + fieldNameEstrazioni), estrazioni), IntegerEntry((keyPrefixN + fieldNameDataRichiesta), currDate), StringEntry((keyPrefixN + fieldNameRichiesta), richiesta)]
159
+
[IntegerEntry(keyCounter, nRichiesta), StringEntry((keyPrefixN + fieldNameSeedB16), toBase16String(seed)), BinaryEntry((keyPrefixN + fieldNameSeed), seed), BinaryEntry("test_vrf", getVrf(getCurrentBlock())), StringEntry("test_vrf", toBase58String(getVrf(getCurrentBlock()))), IntegerEntry((keyPrefixN + fieldNameHeightExtraction), heightExtraction), IntegerEntry((keyPrefixN + fieldNameCardinalita), cardinalita), IntegerEntry((keyPrefixN + fieldNameEstrazioni), estrazioni), IntegerEntry((keyPrefixN + fieldNameDataRichiesta), currDate), StringEntry((keyPrefixN + fieldNameRichiesta), richiesta)]
153
160
 
    }
154
161
 
155
162
 

Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 5 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
let delayBlock = 1
5
5
 
6
6
 
let fieldNameRisultato = "seme_estratto"
7
7
 
8
8
 
let fieldNameSeed = "seed"
9
9
 
10
10
 
let fieldNameSeedB16 = "seed_b16"
11
11
 
12
12
 
let fieldNameHeightExtraction = "height_extraction"
13
13
 
14
14
 
let fieldNameJson = "json"
15
15
 
16
16
 
let fieldNameCardinalita = "cardinalita"
17
17
 
18
18
 
let fieldNameDataRichiesta = "data_richiesta"
19
19
 
20
20
 
let fieldNameEstrazioni = "estrazioni"
21
21
 
22
22
 
let fieldNameRichiesta = "richiesta"
23
23
 
24
24
 
let fieldNameCounter = "counter"
25
25
 
26
26
 
let fieldNameIdCounter = "id_richiesta"
27
27
 
28
28
 
func openJson (key,value) = ((("{\"" + key) + "\":\"") + value)
29
29
 
30
30
 
31
31
 
func addJson (key,value) = ((("\", \"" + key) + "\":\" ") + value)
32
32
 
33
33
 
34
34
 
func closeJson (key,value) = (((("\", \"" + key) + "\":\" ") + value) + "\"}")
35
35
 
36
36
 
37
37
 
func myGetInt (key,msg) = {
38
38
 
    let myInt =     match getInteger(this, key) {
39
39
 
        case t: Int => 
40
40
 
            t
41
41
 
        case _ => 
42
42
 
            throw(msg)
43
43
 
    }
44
44
 
    myInt
45
45
 
    }
46
46
 
47
47
 
48
+
func getCurrentBlock () = {
49
+
    let block =     match blockInfoByHeight(height) {
50
+
        case x: BlockInfo => 
51
+
            x
52
+
        case _ => 
53
+
            throw("Alla ricerca del blocco corrente: Blocco non trovato!")
54
+
    }
55
+
    block
56
+
    }
57
+
58
+
48
59
 
func getTimestamp () = {
49
60
 
    let block =     match blockInfoByHeight(height) {
50
61
 
        case x: BlockInfo => 
51
62
 
            x.timestamp
52
63
 
        case _ => 
53
64
 
            throw("Alla ricerca del `timestamp`: Blocco non trovato!")
54
65
 
    }
55
66
 
    block
56
67
 
    }
57
68
 
58
69
 
59
-
func getVrf () = {
60
-
    let block =     match blockInfoByHeight(height) {
61
-
        case x: BlockInfo => 
62
-
            match x.vrf {
63
-
                case t: ByteVector => 
64
-
                    t
65
-
                case _ => 
66
-
                    throw("Alla ricerca del `vrf`: Blocco non trovato!")
67
-
            }
70
+
func getVrf (thisBlock) = {
71
+
    let vrf =     match thisBlock.vrf {
72
+
        case t: ByteVector => 
73
+
            t
68
74
 
        case _ => 
69
-
            throw("Alla ricerca del `vrf`: Blocco non trovato!")
75
+
            throw("Alla ricerca del `vrf`: Blocco non trovato o blocco non in versione 5 ritenta.")
70
76
 
    }
71
-
    block
77
+
    vrf
72
78
 
    }
73
79
 
74
80
 
75
81
 
func randomizer (inv) = {
76
-
    let rand = (((((getVrf() + inv.transactionId) + inv.callerPublicKey) + lastBlock.generationSignature) + toBytes(lastBlock.timestamp)) + toBytes(lastBlock.height))
82
+
    let currentBlock = getCurrentBlock()
83
+
    let rand = (((((inv.transactionId + inv.callerPublicKey) + getVrf(currentBlock)) + currentBlock.generationSignature) + toBytes(currentBlock.timestamp)) + toBytes(currentBlock.height))
77
84
 
    sha256_16Kb(sha256_16Kb(rand))
78
85
 
    }
79
86
 
80
87
 
81
88
 
@Callable(i)
82
89
 
func estrai (richiesta,numero) = {
83
90
 
    let keyPrefix = (((toString(i.caller) + "_") + richiesta) + "_")
84
91
 
    let keyCounter = (keyPrefix + fieldNameCounter)
85
92
 
    let maxRichiesta = myGetInt(keyCounter, "La richiesta fatta non è stata ancora registrata")
86
93
 
    let numeroRichiesta = if ((0 >= numero))
87
94
 
        then maxRichiesta
88
95
 
        else if ((maxRichiesta >= numero))
89
96
 
            then numero
90
97
 
            else throw("Non esiste una richiesta con questo numero")
91
98
 
    let keyPrefixN = ((keyPrefix + toString(numeroRichiesta)) + "_")
92
99
 
    let keyRisultato = (keyPrefixN + fieldNameRisultato)
93
100
 
    let isEstratto =     match getString(this, keyRisultato) {
94
101
 
        case t: String => 
95
102
 
            throw(("Risultato già presente in blockchain: " + keyRisultato))
96
103
 
        case _ => 
97
104
 
            false
98
105
 
    }
99
106
 
    if (!(isEstratto))
100
107
 
        then {
101
108
 
            let heightBloccoCandidato = myGetInt((keyPrefixN + fieldNameHeightExtraction), "Errore generico su dati della richiesta")
102
109
 
            if ((heightBloccoCandidato > height))
103
110
 
                then throw(("Devi aspettare il blocco " + toString(heightBloccoCandidato)))
104
111
 
                else {
105
112
 
                    let keySeme = (keyPrefixN + fieldNameSeed)
106
113
 
                    let seed =                     match getBinary(this, keySeme) {
107
114
 
                        case t: ByteVector => 
108
115
 
                            t
109
116
 
                        case _ => 
110
117
 
                            throw("Seme non trovato. Qualcosa è andata storta!")
111
118
 
                    }
112
119
 
                    let bloccoCandidato =                     match blockInfoByHeight(heightBloccoCandidato) {
113
120
 
                        case block: BlockInfo => 
114
121
 
                            block
115
122
 
                        case _ => 
116
123
 
                            throw("Errore: Il blocco di estrazione non esiste")
117
124
 
                    }
118
125
 
                    let vrfValue =                     match bloccoCandidato.vrf {
119
126
 
                        case t: ByteVector => 
120
127
 
                            t
121
128
 
                        case _ => 
122
129
 
                            throw("Blocco non in versione 5 ritenta.")
123
130
 
                    }
124
-
                    let rand = (((seed + bloccoCandidato.generationSignature) + bloccoCandidato.generatorPublicKey) + vrfValue)
131
+
                    let rand = (((seed + bloccoCandidato.generationSignature) + bloccoCandidato.generatorPublicKey) + getVrf(bloccoCandidato))
125
132
 
                    let sha = toBase16String(sha256_16Kb(sha256_16Kb(rand)))
126
133
 
                    let strCardinalita = toString(myGetInt((keyPrefixN + fieldNameCardinalita), "Errore lettura cardinalità"))
127
134
 
                    let strDataRichiesta = toString(myGetInt((keyPrefixN + fieldNameDataRichiesta), "Errore lettura DataRichiesta"))
128
135
 
                    let strEstrazioni = toString(myGetInt((keyPrefixN + fieldNameEstrazioni), "Errore lettura Estrazioni"))
129
136
 
                    let json = ((((((((openJson(fieldNameIdCounter, toString(numeroRichiesta)) + addJson(fieldNameCounter, toString(maxRichiesta))) + addJson(fieldNameRichiesta, richiesta)) + addJson(fieldNameCardinalita, strCardinalita)) + addJson(fieldNameEstrazioni, strEstrazioni)) + addJson(fieldNameDataRichiesta, strDataRichiesta)) + addJson(fieldNameSeedB16, toBase16String(seed))) + addJson(fieldNameHeightExtraction, toString(heightBloccoCandidato))) + closeJson(fieldNameRisultato, sha))
130
137
 
[StringEntry((keyPrefixN + fieldNameJson), json), StringEntry(keyRisultato, sha)]
131
138
 
                    }
132
139
 
            }
133
140
 
        else throw("Errore: non dovresti passare da quì")
134
141
 
    }
135
142
 
136
143
 
137
144
 
138
145
 
@Callable(i)
139
146
 
func registra (richiesta,cardinalita,estrazioni) = {
140
147
 
    let keyPrefix = (((toString(i.caller) + "_") + richiesta) + "_")
141
148
 
    let keyCounter = (keyPrefix + fieldNameCounter)
142
149
 
    let nRichiesta =     match getInteger(this, keyCounter) {
143
150
 
        case c: Int => 
144
151
 
            (c + 1)
145
152
 
        case _ => 
146
153
 
            1
147
154
 
    }
148
155
 
    let keyPrefixN = ((keyPrefix + toString(nRichiesta)) + "_")
149
156
 
    let seed = randomizer(i)
150
157
 
    let currDate = getTimestamp()
151
158
 
    let heightExtraction = (height + delayBlock)
152
-
[IntegerEntry(keyCounter, nRichiesta), StringEntry((keyPrefixN + fieldNameSeedB16), toBase16String(seed)), BinaryEntry((keyPrefixN + fieldNameSeed), seed), StringEntry("test_vrf", toBase58String(getVrf())), IntegerEntry((keyPrefixN + fieldNameHeightExtraction), heightExtraction), IntegerEntry((keyPrefixN + fieldNameCardinalita), cardinalita), IntegerEntry((keyPrefixN + fieldNameEstrazioni), estrazioni), IntegerEntry((keyPrefixN + fieldNameDataRichiesta), currDate), StringEntry((keyPrefixN + fieldNameRichiesta), richiesta)]
159
+
[IntegerEntry(keyCounter, nRichiesta), StringEntry((keyPrefixN + fieldNameSeedB16), toBase16String(seed)), BinaryEntry((keyPrefixN + fieldNameSeed), seed), BinaryEntry("test_vrf", getVrf(getCurrentBlock())), StringEntry("test_vrf", toBase58String(getVrf(getCurrentBlock()))), IntegerEntry((keyPrefixN + fieldNameHeightExtraction), heightExtraction), IntegerEntry((keyPrefixN + fieldNameCardinalita), cardinalita), IntegerEntry((keyPrefixN + fieldNameEstrazioni), estrazioni), IntegerEntry((keyPrefixN + fieldNameDataRichiesta), currDate), StringEntry((keyPrefixN + fieldNameRichiesta), richiesta)]
153
160
 
    }
154
161
 
155
162
 

github/deemru/w8io/873ac7e 
32.35 ms ◑