tx · 8fMC67NrmMcyNDf1J5NPgF9DBUKdFbuEWbRhffrxeD8Q

3N54eKW5ZucDaRaGVUfzX8xRXv6Ve8M71tM:  -0.02000000 Waves

2020.05.14 16:01 [997916] smart account 3N54eKW5ZucDaRaGVUfzX8xRXv6Ve8M71tM > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "8fMC67NrmMcyNDf1J5NPgF9DBUKdFbuEWbRhffrxeD8Q",
    "fee": 2000000,
    "feeAssetId": null,
    "timestamp": 1589461241197,
    "version": 1,
    "sender": "3N54eKW5ZucDaRaGVUfzX8xRXv6Ve8M71tM",
    "senderPublicKey": "FmnQ1LwTnauTS2BSrZivE1nSF1A9MY9hyYB72pyh5hw9",
    "proofs": [
        "3fvf5bNh3CTCsj6cZZmhYxsLVJDtdH1eyqbk99PqNmEWqW8yTQTwTNGJ6QFQKEVYQVKzmXrrTHF8JWfsVJTnM5ca"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 997916,
    "spentComplexity": 0
}

View: original | compacted
Prev: D3dfmhB3gakuX9bH8nAbu76EtPSkmuGmqdvT9crFdu36
Next: 5ycabj5qLtD6K4MQnyfJ8BbdQ2QfoYMA5qY8M8c9WFHc

Diff: 
Old
New
Differences
177
177
 
178
178
 
179
179
 
@Callable(contextObj)
180
-
func decodeCryptoPrice (data) = {
180
+
func testDecodeCryptoPrice (data) = {
181
181
 
    let offset = 0
182
182
 
    let tuple1 = decodeString(data, offset)
183
183
 
    let tuple2 = decodeInt64(data, getOffset(tuple1))
184
184
 
    WriteSet([DataEntry("symbol", getAsString(tuple1)), DataEntry("multiplier", tuple2[0])])
185
+
    }
186
+
187
+
188
+
189
+
@Callable(contextObj)
190
+
func testDecodeResponsePacket (data) = {
191
+
    let tuple1 = decodeString(data, 0)
192
+
    let tuple2 = decodeInt64(data, getOffset(tuple1))
193
+
    let tuple3 = decodeInt64(data, tuple2[1])
194
+
    let tuple4 = decodeInt64(data, tuple3[1])
195
+
    let tuple5 = decodeInt64(data, tuple4[1])
196
+
    let tuple6 = decodeInt8(data, tuple5[1])
197
+
    let tuple7 = decodeBytes(data, tuple6[1])
198
+
    let priceBytes = getAsByteVector(tuple7)
199
+
    let tuple8 = decodeString(priceBytes, 0)
200
+
    let tuple9 = decodeString(priceBytes, getOffset(tuple8))
201
+
    WriteSet([DataEntry("responsePacket/clientId", getAsString(tuple1)), DataEntry("responsePacket/requestId", tuple2[0]), DataEntry("responsePacket/ansCount", tuple3[0]), DataEntry("responsePacket/requestTime", tuple4[0]), DataEntry("responsePacket/resolveTime", tuple5[0]), DataEntry("responsePacket/resolveStatus", tuple6[0]), DataEntry("responsePacket/result/symbol", getAsString(tuple8)), DataEntry("responsePacket/result/multiplier", getAsString(tuple9))])
185
202
 
    }
186
203
 
187
204
 

Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 3 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
func decodeInt8 (data,offset) = if ((1 > size(data)))
5
5
 
    then throw("decode u8 error, data must be at least 1 byte")
6
6
 
    else if ((offset > size(data)))
7
7
 
        then throw("decode u8 error, decoding is finish")
8
8
 
        else {
9
9
 
            let x0 = take(drop(data, offset), 1)
10
10
 
            let x1 = toInt((base58'1111111' + x0), 0)
11
11
 
            if ((128 > x1))
12
12
 
                then [x1, (offset + 1)]
13
13
 
                else [toInt((base58'Ahg1opVcGW' + x0), 0), (offset + 1)]
14
14
 
            }
15
15
 
16
16
 
17
17
 
func decodeInt16 (data,offset) = if ((2 > size(data)))
18
18
 
    then throw("decode u16 error, data must be at least 2 bytes")
19
19
 
    else if ((offset > size(data)))
20
20
 
        then throw("decode u16 error, decoding is finish")
21
21
 
        else {
22
22
 
            let x0 = drop(data, offset)
23
23
 
            let x1 = take(x0, 1)
24
24
 
            let x2 = take(drop(x0, 1), 1)
25
25
 
            if ((decodeInt8(x2, 0)[0] >= 0))
26
26
 
                then [toInt(((base58'111111' + x2) + x1), 0), (offset + 2)]
27
27
 
                else [toInt(((base58'3CUsUpv9t' + x2) + x1), 0), (offset + 2)]
28
28
 
            }
29
29
 
30
30
 
31
31
 
func decodeInt32 (data,offset) = if ((4 > size(data)))
32
32
 
    then throw("decode u32 error, data must be at least 4 bytes")
33
33
 
    else if ((offset > size(data)))
34
34
 
        then throw("decode u32 error, decoding is finish")
35
35
 
        else {
36
36
 
            let x0 = drop(data, offset)
37
37
 
            let x1 = take(x0, 1)
38
38
 
            let x2 = take(drop(x0, 1), 1)
39
39
 
            let x3 = take(drop(x0, 2), 1)
40
40
 
            let x4 = take(drop(x0, 3), 1)
41
41
 
            if ((decodeInt8(x4, 0)[0] >= 0))
42
42
 
                then [toInt(((((base58'1111' + x4) + x3) + x2) + x1), 0), (offset + 4)]
43
43
 
                else [toInt(((((base58'7YXq9G' + x4) + x3) + x2) + x1), 0), (offset + 4)]
44
44
 
            }
45
45
 
46
46
 
47
47
 
func decodeInt64 (data,offset) = if ((8 > size(data)))
48
48
 
    then throw("decode u32 error, data must be at least 8 bytes")
49
49
 
    else if ((offset > size(data)))
50
50
 
        then throw("decode u32 error, decoding is finish")
51
51
 
        else {
52
52
 
            let x0 = drop(data, offset)
53
53
 
            let x1 = take(x0, 1)
54
54
 
            let x2 = take(drop(x0, 1), 1)
55
55
 
            let x3 = take(drop(x0, 2), 1)
56
56
 
            let x4 = take(drop(x0, 3), 1)
57
57
 
            let x5 = take(drop(x0, 4), 1)
58
58
 
            let x6 = take(drop(x0, 5), 1)
59
59
 
            let x7 = take(drop(x0, 6), 1)
60
60
 
            let x8 = take(drop(x0, 7), 1)
61
61
 
[toInt((((((((x8 + x7) + x6) + x5) + x4) + x3) + x2) + x1), 0), (offset + 8)]
62
62
 
            }
63
63
 
64
64
 
65
65
 
func decodeBool (data,offset) = {
66
66
 
    let decoded1 = decodeInt8(data, offset)
67
67
 
[DataEntry("bool", (decoded1[0] != 0)), DataEntry("int", decoded1[1])]
68
68
 
    }
69
69
 
70
70
 
71
71
 
func decodeBytes32 (data,offset) = if ((32 > size(data)))
72
72
 
    then throw("decode bytes32 error, data must be at least 32 bytes")
73
73
 
    else [DataEntry("byte_vector", take(drop(data, offset), 32)), DataEntry("int", (offset + 32))]
74
74
 
75
75
 
76
76
 
func decodeBytes64 (data,offset) = if ((64 > size(data)))
77
77
 
    then throw("decode bytes64 error, data must be at least 64 bytes")
78
78
 
    else [DataEntry("byte_vector", take(drop(data, offset), 64)), DataEntry("int", (offset + 64))]
79
79
 
80
80
 
81
81
 
func decodeBytes65 (data,offset) = if ((65 > size(data)))
82
82
 
    then throw("decode bytes65 error, data must be at least 65 bytes")
83
83
 
    else [DataEntry("byte_vector", take(drop(data, offset), 65)), DataEntry("int", (offset + 65))]
84
84
 
85
85
 
86
86
 
func decodeBytes (data,offset) = {
87
87
 
    let decoded1 = decodeInt32(data, offset)
88
88
 
    let bytesSize = decoded1[0]
89
89
 
    let nextOffset = decoded1[1]
90
90
 
[DataEntry("byte_vector", take(drop(data, nextOffset), bytesSize)), DataEntry("int", (nextOffset + bytesSize))]
91
91
 
    }
92
92
 
93
93
 
94
94
 
func decodeString (data,offset) = {
95
95
 
    let decoded1 = decodeInt32(data, offset)
96
96
 
    let bytesSize = decoded1[0]
97
97
 
    let nextOffset = decoded1[1]
98
98
 
[DataEntry("string", toUtf8String(take(drop(data, nextOffset), bytesSize))), DataEntry("int", (nextOffset + bytesSize))]
99
99
 
    }
100
100
 
101
101
 
102
102
 
func getAsBool (tuple) = match tuple[0].value {
103
103
 
    case b: Boolean => 
104
104
 
        b
105
105
 
    case _ => 
106
106
 
        throw("not a Boolean")
107
107
 
}
108
108
 
109
109
 
110
110
 
func getAsByteVector (tuple) = match tuple[0].value {
111
111
 
    case bv: ByteVector => 
112
112
 
        bv
113
113
 
    case _ => 
114
114
 
        throw("not a ByteVector")
115
115
 
}
116
116
 
117
117
 
118
118
 
func getAsString (tuple) = match tuple[0].value {
119
119
 
    case s: String => 
120
120
 
        s
121
121
 
    case _ => 
122
122
 
        throw("not a String")
123
123
 
}
124
124
 
125
125
 
126
126
 
func getOffset (tuple) = match tuple[1].value {
127
127
 
    case i: Int => 
128
128
 
        i
129
129
 
    case _ => 
130
130
 
        throw("not a Int")
131
131
 
}
132
132
 
133
133
 
134
134
 
@Callable(contextObj)
135
135
 
func testDecodeInt16 (data) = {
136
136
 
    let offset = 0
137
137
 
    let x1 = decodeInt16(data, offset)
138
138
 
    WriteSet([DataEntry("i16", x1[0])])
139
139
 
    }
140
140
 
141
141
 
142
142
 
143
143
 
@Callable(contextObj)
144
144
 
func testDecodeInt64 (data) = {
145
145
 
    let offset = 0
146
146
 
    let decoded = decodeInt64(data, offset)
147
147
 
    WriteSet([DataEntry("i64", decoded[0])])
148
148
 
    }
149
149
 
150
150
 
151
151
 
152
152
 
@Callable(contextObj)
153
153
 
func testDecodeString (data) = {
154
154
 
    let offset = 0
155
155
 
    let decoded = decodeString(data, offset)
156
156
 
    WriteSet([DataEntry("string", getAsString(decoded))])
157
157
 
    }
158
158
 
159
159
 
160
160
 
161
161
 
@Callable(contextObj)
162
162
 
func testDecodeBytes (data) = {
163
163
 
    let offset = 0
164
164
 
    let decoded = decodeBytes(data, offset)
165
165
 
    WriteSet([DataEntry("bytes", getAsByteVector(decoded))])
166
166
 
    }
167
167
 
168
168
 
169
169
 
170
170
 
@Callable(contextObj)
171
171
 
func testDecodeBytes32 (data) = {
172
172
 
    let offset = 0
173
173
 
    let decoded = decodeBytes32(data, offset)
174
174
 
    WriteSet([DataEntry("bytes", getAsByteVector(decoded))])
175
175
 
    }
176
176
 
177
177
 
178
178
 
179
179
 
@Callable(contextObj)
180
-
func decodeCryptoPrice (data) = {
180
+
func testDecodeCryptoPrice (data) = {
181
181
 
    let offset = 0
182
182
 
    let tuple1 = decodeString(data, offset)
183
183
 
    let tuple2 = decodeInt64(data, getOffset(tuple1))
184
184
 
    WriteSet([DataEntry("symbol", getAsString(tuple1)), DataEntry("multiplier", tuple2[0])])
185
+
    }
186
+
187
+
188
+
189
+
@Callable(contextObj)
190
+
func testDecodeResponsePacket (data) = {
191
+
    let tuple1 = decodeString(data, 0)
192
+
    let tuple2 = decodeInt64(data, getOffset(tuple1))
193
+
    let tuple3 = decodeInt64(data, tuple2[1])
194
+
    let tuple4 = decodeInt64(data, tuple3[1])
195
+
    let tuple5 = decodeInt64(data, tuple4[1])
196
+
    let tuple6 = decodeInt8(data, tuple5[1])
197
+
    let tuple7 = decodeBytes(data, tuple6[1])
198
+
    let priceBytes = getAsByteVector(tuple7)
199
+
    let tuple8 = decodeString(priceBytes, 0)
200
+
    let tuple9 = decodeString(priceBytes, getOffset(tuple8))
201
+
    WriteSet([DataEntry("responsePacket/clientId", getAsString(tuple1)), DataEntry("responsePacket/requestId", tuple2[0]), DataEntry("responsePacket/ansCount", tuple3[0]), DataEntry("responsePacket/requestTime", tuple4[0]), DataEntry("responsePacket/resolveTime", tuple5[0]), DataEntry("responsePacket/resolveStatus", tuple6[0]), DataEntry("responsePacket/result/symbol", getAsString(tuple8)), DataEntry("responsePacket/result/multiplier", getAsString(tuple9))])
185
202
 
    }
186
203
 
187
204
 
188
205
 
189
206
 
@Callable(contextObj)
190
207
 
func testCutLongBytes (data) = {
191
208
 
    let offset = 0
192
209
 
    let decoded = decodeInt64(drop(data, (size(data) - 8)), offset)
193
210
 
    WriteSet([DataEntry("test_cut_long_bytes_to_i64", decoded[0])])
194
211
 
    }
195
212
 
196
213
 
197
214
 
198
215
 
@Callable(contextObj)
199
216
 
func setValidator (validator) = if ((contextObj.caller == this))
200
217
 
    then WriteSet([DataEntry("validator", validator)])
201
218
 
    else throw("Only owner can use this function.")
202
219
 
203
220
 
204
221
 
205
222
 
@Callable(contextObj)
206
223
 
func reportData (data) = {
207
224
 
    let validator = getBinary(this, "validator")
208
225
 
    if ((contextObj.caller.bytes == validator))
209
226
 
        then WriteSet([DataEntry("data_reported", data)])
210
227
 
        else throw("Only validator can use this function.")
211
228
 
    }
212
229
 
213
230
 

github/deemru/w8io/169f3d6 
118.44 ms ◑