1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
package salticidae
// #include <stdlib.h>
// #include "salticidae/stream.h"
import "C"
import "runtime"
type byteArray struct {
inner *C.bytearray_t
}
type ByteArray = *byteArray
func NewByteArray() ByteArray {
res := &byteArray{ inner: C.bytearray_new() }
runtime.SetFinalizer(res, func(self ByteArray) { self.free() })
return res
}
func (self ByteArray) free() { C.bytearray_free(self.inner) }
func NewByteArrayMovedFromDataStream(src DataStream) ByteArray {
res := &byteArray{ inner: C.bytearray_new_moved_from_datastream(src.inner) }
runtime.SetFinalizer(res, func(self ByteArray) { self.free() })
return res
}
type dataStream struct {
inner *C.datastream_t
}
type DataStream = *dataStream
func NewDataStream() DataStream {
res := &dataStream{ inner: C.datastream_new() }
runtime.SetFinalizer(res, func(self DataStream) { self.free() })
return res
}
func NewDataStreamFromBytes(bytes []byte) (res DataStream) {
size := len(bytes)
if size > 0 {
base := (*C.uint8_t)(&bytes[0])
res = &dataStream{ inner: C.datastream_new_from_bytes(base, C.size_t(size)) }
} else {
res = &dataStream{ inner: C.datastream_new() }
}
runtime.SetFinalizer(res, func(self DataStream) { self.free() })
return
}
func (self DataStream) free() { C.datastream_free(self.inner) }
func (self DataStream) AssignByCopy(src DataStream) {
C.datastream_assign_by_copy(self.inner, src.inner)
}
func (self DataStream) AssignByMove(src DataStream) {
C.datastream_assign_by_move(self.inner, src.inner)
}
// TODO: datastream_data
func (self DataStream) Clear() { C.datastream_clear(self.inner) }
func (self DataStream) Size() int { return int(C.datastream_size(self.inner)) }
func (self DataStream) PutU8(v uint8) bool { return bool(C.datastream_put_u8(self.inner, C.uint8_t(v))) }
func (self DataStream) PutU16(v uint16) bool { return bool(C.datastream_put_u16(self.inner, C.uint16_t(v))) }
func (self DataStream) PutU32(v uint32) bool { return bool(C.datastream_put_u32(self.inner, C.uint32_t(v))) }
func (self DataStream) PutU64(v uint32) bool { return bool(C.datastream_put_u64(self.inner, C.uint64_t(v))) }
func (self DataStream) PutI8(v int8) bool { return bool(C.datastream_put_i8(self.inner, C.int8_t(v))) }
func (self DataStream) PutI16(v int16) bool { return bool(C.datastream_put_i16(self.inner, C.int16_t(v))) }
func (self DataStream) PutI32(v int32) bool { return bool(C.datastream_put_i32(self.inner, C.int32_t(v))) }
func (self DataStream) PutI64(v int32) bool { return bool(C.datastream_put_i64(self.inner, C.int64_t(v))) }
func (self DataStream) PutData(bytes []byte) bool {
size := len(bytes)
if size > 0 {
base := (*C.uint8_t)(&bytes[0])
return bool(C.datastream_put_data(self.inner, base, C.size_t(size)))
} else { return true }
}
func (self DataStream) GetU8(succ *bool) uint8 { return uint8(C.datastream_get_u8(self.inner, (*C.bool)(succ))) }
func (self DataStream) GetU16(succ *bool) uint16 { return uint16(C.datastream_get_u16(self.inner, (*C.bool)(succ))) }
func (self DataStream) GetU32(succ *bool) uint32 { return uint32(C.datastream_get_u32(self.inner, (*C.bool)(succ))) }
func (self DataStream) GetU64(succ *bool) uint64 { return uint64(C.datastream_get_u64(self.inner, (*C.bool)(succ))) }
func (self DataStream) GetI8(succ *bool) int8 { return int8(C.datastream_get_i8(self.inner, (*C.bool)(succ))) }
func (self DataStream) GetI16(succ *bool) int16 { return int16(C.datastream_get_i16(self.inner, (*C.bool)(succ))) }
func (self DataStream) GetI32(succ *bool) int32 { return int32(C.datastream_get_i32(self.inner, (*C.bool)(succ))) }
func (self DataStream) GetI64(succ *bool) int64 { return int64(C.datastream_get_i64(self.inner, (*C.bool)(succ))) }
func (self DataStream) GetDataInPlace(length int) []byte {
base := C.datastream_get_data_inplace(self.inner, C.size_t(length))
return C.GoBytes(rawptr_t(base), C.int(length))
}
type uint256 struct {
inner *C.uint256_t
}
type UInt256 = *uint256
func NewUInt256() UInt256 {
res := &uint256{ inner: C.uint256_new() }
runtime.SetFinalizer(res, func(self UInt256) { self.free() })
return res
}
func (self UInt256) free() { C.uint256_free(self.inner) }
func (self UInt256) UInt256IsNull() bool { return bool(C.uint256_is_null(self.inner)) }
func (self UInt256) UInt256IsEq(other UInt256) bool { return bool(C.uint256_is_eq(self.inner, other.inner)) }
func (self UInt256) Serialize(s DataStream) { C.uint256_serialize(self.inner, s.inner) }
func (self UInt256) Unserialize(s DataStream) { C.uint256_unserialize(self.inner, s.inner) }
func (self UInt256) IsEq(other UInt256) bool { return bool(C.uint256_is_eq(self.inner, other.inner)) }
func (self DataStream) GetHash() UInt256 {
res := &uint256{ inner: C.datastream_get_hash(self.inner) }
runtime.SetFinalizer(res, func(self UInt256) { self.free() })
return res
}
func (self DataStream) GetHex() string {
tmp := C.datastream_get_hex(self.inner)
res := C.GoString(tmp)
C.free(rawptr_t(tmp))
return res
}
func (self UInt256) GetHex() string {
s := NewDataStream()
self.Serialize(s)
res := s.GetHex()
return res
}
|