Golang implemented sidechain for Bytom
リビジョン | 8ccbfd62cef32573177a65aa7a0c7e3cc6b8b91d (tree) |
---|---|
日時 | 2019-09-24 15:31:32 |
作者 | wz <mars@byto...> |
コミッター | wz |
database struct
@@ -0,0 +1,293 @@ | ||
1 | +package dex | |
2 | + | |
3 | +import ( | |
4 | + "encoding/binary" | |
5 | + "encoding/json" | |
6 | + "io/ioutil" | |
7 | + "math" | |
8 | + "os" | |
9 | + "testing" | |
10 | + | |
11 | + "github.com/stretchr/testify/require" | |
12 | + "golang.org/x/crypto/sha3" | |
13 | + | |
14 | + "github.com/vapor/database/leveldb" | |
15 | + "github.com/vapor/dex" | |
16 | + "github.com/vapor/protocol/bc" | |
17 | + "github.com/vapor/testutil" | |
18 | +) | |
19 | + | |
20 | +func TestOrderKey(t *testing.T) { | |
21 | + dirname, err := ioutil.TempDir("", "db_common_test") | |
22 | + require.Nil(t, err) | |
23 | + | |
24 | + db, err := leveldb.NewGoLevelDB("testdb", dirname) | |
25 | + if err != nil { | |
26 | + t.Fatal(err) | |
27 | + } | |
28 | + | |
29 | + defer func() { | |
30 | + db.Close() | |
31 | + os.RemoveAll(dirname) | |
32 | + }() | |
33 | + | |
34 | + type expectedData struct { | |
35 | + rate float64 | |
36 | + utxoHash string | |
37 | + } | |
38 | + | |
39 | + cases := []struct { | |
40 | + orders []dex.Order | |
41 | + want []expectedData | |
42 | + }{ | |
43 | + { | |
44 | + orders: []dex.Order{ | |
45 | + dex.Order{ | |
46 | + ToAssetID: bc.AssetID{V0: 0}, | |
47 | + Rate: 1.00090, | |
48 | + Utxo: dex.DexUtxo{ | |
49 | + SourceID: bc.Hash{V0: 21}, | |
50 | + AssetID: bc.AssetID{V0: 1}, | |
51 | + Amount: 1, | |
52 | + SourcePos: 0, | |
53 | + ControlProgram: []byte("aa"), | |
54 | + }, | |
55 | + }, | |
56 | + dex.Order{ | |
57 | + ToAssetID: bc.AssetID{V0: 0}, | |
58 | + Rate: 0.00090, | |
59 | + Utxo: dex.DexUtxo{ | |
60 | + SourceID: bc.Hash{V0: 22}, | |
61 | + AssetID: bc.AssetID{V0: 1}, | |
62 | + Amount: 1, | |
63 | + SourcePos: 0, | |
64 | + ControlProgram: []byte("aa"), | |
65 | + }, | |
66 | + }, | |
67 | + dex.Order{ | |
68 | + ToAssetID: bc.AssetID{V0: 0}, | |
69 | + Rate: 0.00097, | |
70 | + Utxo: dex.DexUtxo{ | |
71 | + SourceID: bc.Hash{V0: 23}, | |
72 | + AssetID: bc.AssetID{V0: 1}, | |
73 | + Amount: 1, | |
74 | + SourcePos: 0, | |
75 | + ControlProgram: []byte("aa"), | |
76 | + }, | |
77 | + }, | |
78 | + dex.Order{ | |
79 | + ToAssetID: bc.AssetID{V0: 0}, | |
80 | + Rate: 0.00098, | |
81 | + Utxo: dex.DexUtxo{ | |
82 | + SourceID: bc.Hash{V0: 13}, | |
83 | + AssetID: bc.AssetID{V0: 1}, | |
84 | + Amount: 1, | |
85 | + SourcePos: 0, | |
86 | + ControlProgram: []byte("aa"), | |
87 | + }, | |
88 | + }, | |
89 | + dex.Order{ | |
90 | + ToAssetID: bc.AssetID{V0: 0}, | |
91 | + Rate: 0.00098, | |
92 | + Utxo: dex.DexUtxo{ | |
93 | + SourceID: bc.Hash{V0: 24}, | |
94 | + AssetID: bc.AssetID{V0: 1}, | |
95 | + Amount: 10, | |
96 | + SourcePos: 1, | |
97 | + ControlProgram: []byte("aa"), | |
98 | + }, | |
99 | + }, | |
100 | + dex.Order{ | |
101 | + ToAssetID: bc.AssetID{V0: 0}, | |
102 | + Rate: 0.00099, | |
103 | + Utxo: dex.DexUtxo{ | |
104 | + SourceID: bc.Hash{V0: 24}, | |
105 | + AssetID: bc.AssetID{V0: 1}, | |
106 | + Amount: 1, | |
107 | + SourcePos: 0, | |
108 | + ControlProgram: []byte("aa"), | |
109 | + }, | |
110 | + }, | |
111 | + dex.Order{ | |
112 | + ToAssetID: bc.AssetID{V0: 0}, | |
113 | + Rate: 0.00096, | |
114 | + Utxo: dex.DexUtxo{ | |
115 | + SourceID: bc.Hash{V0: 25}, | |
116 | + AssetID: bc.AssetID{V0: 1}, | |
117 | + Amount: 1, | |
118 | + SourcePos: 0, | |
119 | + ControlProgram: []byte("aa"), | |
120 | + }, | |
121 | + }, | |
122 | + dex.Order{ | |
123 | + ToAssetID: bc.AssetID{V0: 0}, | |
124 | + Rate: 0.00095, | |
125 | + Utxo: dex.DexUtxo{ | |
126 | + SourceID: bc.Hash{V0: 26}, | |
127 | + AssetID: bc.AssetID{V0: 1}, | |
128 | + Amount: 1, | |
129 | + SourcePos: 0, | |
130 | + ControlProgram: []byte("aa"), | |
131 | + }, | |
132 | + }, | |
133 | + dex.Order{ | |
134 | + ToAssetID: bc.AssetID{V0: 0}, | |
135 | + Rate: 0.00091, | |
136 | + Utxo: dex.DexUtxo{ | |
137 | + SourceID: bc.Hash{V0: 26}, | |
138 | + AssetID: bc.AssetID{V0: 1}, | |
139 | + Amount: 1, | |
140 | + SourcePos: 0, | |
141 | + ControlProgram: []byte("aa"), | |
142 | + }, | |
143 | + }, | |
144 | + dex.Order{ | |
145 | + ToAssetID: bc.AssetID{V0: 0}, | |
146 | + Rate: 0.00092, | |
147 | + Utxo: dex.DexUtxo{ | |
148 | + SourceID: bc.Hash{V0: 27}, | |
149 | + AssetID: bc.AssetID{V0: 1}, | |
150 | + Amount: 1, | |
151 | + SourcePos: 0, | |
152 | + ControlProgram: []byte("aa"), | |
153 | + }, | |
154 | + }, | |
155 | + dex.Order{ | |
156 | + ToAssetID: bc.AssetID{V0: 0}, | |
157 | + Rate: 0.00093, | |
158 | + Utxo: dex.DexUtxo{ | |
159 | + SourceID: bc.Hash{V0: 28}, | |
160 | + AssetID: bc.AssetID{V0: 1}, | |
161 | + Amount: 1, | |
162 | + SourcePos: 0, | |
163 | + ControlProgram: []byte("aa"), | |
164 | + }, | |
165 | + }, | |
166 | + dex.Order{ | |
167 | + ToAssetID: bc.AssetID{V0: 0}, | |
168 | + Rate: 0.00094, | |
169 | + Utxo: dex.DexUtxo{ | |
170 | + SourceID: bc.Hash{V0: 29}, | |
171 | + AssetID: bc.AssetID{V0: 1}, | |
172 | + Amount: 1, | |
173 | + SourcePos: 0, | |
174 | + ControlProgram: []byte("aa"), | |
175 | + }, | |
176 | + }, | |
177 | + dex.Order{ | |
178 | + ToAssetID: bc.AssetID{V0: 0}, | |
179 | + Rate: 0.00077, | |
180 | + Utxo: dex.DexUtxo{ | |
181 | + SourceID: bc.Hash{V0: 30}, | |
182 | + AssetID: bc.AssetID{V0: 1}, | |
183 | + Amount: 1, | |
184 | + SourcePos: 0, | |
185 | + ControlProgram: []byte("aa"), | |
186 | + }, | |
187 | + }, | |
188 | + dex.Order{ | |
189 | + ToAssetID: bc.AssetID{V0: 0}, | |
190 | + Rate: 0.00088, | |
191 | + Utxo: dex.DexUtxo{ | |
192 | + SourceID: bc.Hash{V0: 31}, | |
193 | + AssetID: bc.AssetID{V0: 1}, | |
194 | + Amount: 1, | |
195 | + SourcePos: 0, | |
196 | + ControlProgram: []byte("aa"), | |
197 | + }, | |
198 | + }, | |
199 | + }, | |
200 | + want: []expectedData{ | |
201 | + expectedData{ | |
202 | + rate: 0.00077, | |
203 | + utxoHash: "1a347f38978f4116667880cd650f90f7117f9e5fa664bf35a762b7542521ecfd", | |
204 | + }, | |
205 | + expectedData{ | |
206 | + rate: 0.00088, | |
207 | + utxoHash: "390f96ae1f453bc9b8274b4e309853df9821f09e73e5d4294a21de94a3e82c9d", | |
208 | + }, | |
209 | + expectedData{ | |
210 | + rate: 0.00090, | |
211 | + utxoHash: "9b6906500e0468b46b05d1cc389e987503d8ff8f6521a9b3cb2e34812edd7e8b", | |
212 | + }, | |
213 | + expectedData{ | |
214 | + rate: 0.00091, | |
215 | + utxoHash: "6be9a8fe98dc3d9404a163d6c25d4c86c07725b2b5274792e3d3991a183b916d", | |
216 | + }, | |
217 | + expectedData{ | |
218 | + rate: 0.00092, | |
219 | + utxoHash: "a8c1cca596b76468f52a4559c468e865781e82a39b68fb337f4fe8cae84df38f", | |
220 | + }, | |
221 | + expectedData{ | |
222 | + rate: 0.00093, | |
223 | + utxoHash: "675344ad2a35fed61ef4028c89a9bd757b5c2d77a0151cf9e7077231d70a5768", | |
224 | + }, | |
225 | + expectedData{ | |
226 | + rate: 0.00094, | |
227 | + utxoHash: "98efa3949171cb01fef826d02fb995351ee833380e34dbe186a663bfe514aeec", | |
228 | + }, | |
229 | + expectedData{ | |
230 | + rate: 0.00095, | |
231 | + utxoHash: "6be9a8fe98dc3d9404a163d6c25d4c86c07725b2b5274792e3d3991a183b916d", | |
232 | + }, | |
233 | + expectedData{ | |
234 | + rate: 0.00096, | |
235 | + utxoHash: "617f55abaaca68f3f4967823448fd6351b84c8104890b1091db070670e456c21", | |
236 | + }, | |
237 | + expectedData{ | |
238 | + rate: 0.00097, | |
239 | + utxoHash: "c4ccb9843d0bb1dbf20d441b3f5c4374421dbfe505d1fb7f3fe551f63e2244d2", | |
240 | + }, | |
241 | + expectedData{ | |
242 | + rate: 0.00098, | |
243 | + utxoHash: "658ad7a433b689bd1b2d167c66eb065b5cc16015bfc0bbc122a8e3c370274ead", | |
244 | + }, | |
245 | + expectedData{ | |
246 | + rate: 0.00098, | |
247 | + utxoHash: "9dcde7ab0f2f88ed5203e4156160cedc21d68defee6f0e41413757b13da2535c", | |
248 | + }, | |
249 | + expectedData{ | |
250 | + rate: 0.00099, | |
251 | + utxoHash: "f2484ada2a12220b20f54552f7a329efdfa455fe062c6247dbe33453c9ff9f3e", | |
252 | + }, | |
253 | + expectedData{ | |
254 | + rate: 1.0009, | |
255 | + utxoHash: "f39ed5eaba9d9e4913a9ae32f6922c056c905d9d0bdc628ae6378fe6cb5196a2", | |
256 | + }, | |
257 | + }, | |
258 | + }, | |
259 | + } | |
260 | + | |
261 | + for i, c := range cases { | |
262 | + for _, order := range c.orders { | |
263 | + data, err := json.Marshal(order.Utxo) | |
264 | + if err != nil { | |
265 | + t.Fatal(err) | |
266 | + } | |
267 | + utxoHash := bc.NewHash(sha3.Sum256(data)) | |
268 | + key := calcOrdersPrefix(&order.Utxo.AssetID, &order.ToAssetID, &utxoHash, order.Rate) | |
269 | + db.SetSync(key, data) | |
270 | + } | |
271 | + | |
272 | + got := []expectedData{} | |
273 | + | |
274 | + itr := db.IteratorPrefixWithStart(nil, nil, false) | |
275 | + for itr.Next() { | |
276 | + key := itr.Key() | |
277 | + pos := len(OrdersPreFix) + 32*2 | |
278 | + b := [32]byte{} | |
279 | + copy(b[:], key[pos+8:]) | |
280 | + utxoHash := bc.NewHash(b) | |
281 | + got = append(got, expectedData{ | |
282 | + rate: math.Float64frombits(binary.BigEndian.Uint64(key[pos : pos+8])), | |
283 | + utxoHash: utxoHash.String(), | |
284 | + }) | |
285 | + } | |
286 | + itr.Release() | |
287 | + | |
288 | + if !testutil.DeepEqual(c.want, got) { | |
289 | + t.Errorf("case %v: got recovery status, got: %v, want: %v.", i, got, c.want) | |
290 | + } | |
291 | + | |
292 | + } | |
293 | +} |
@@ -0,0 +1,76 @@ | ||
1 | +package dex | |
2 | + | |
3 | +import ( | |
4 | + "encoding/binary" | |
5 | + "math" | |
6 | + | |
7 | + dbm "github.com/vapor/database/leveldb" | |
8 | + "github.com/vapor/dex" | |
9 | + "github.com/vapor/protocol/bc" | |
10 | +) | |
11 | + | |
12 | +const ( | |
13 | + order byte = iota | |
14 | + tradePair | |
15 | + matchStatus | |
16 | +) | |
17 | + | |
18 | +var ( | |
19 | + dexStore = []byte("DEX:") | |
20 | + OrdersPreFix = append(dexStore, order) | |
21 | + TradePairPreFix = append(dexStore, tradePair) | |
22 | + bestMatchStore = append(dexStore, matchStatus) | |
23 | +) | |
24 | + | |
25 | +func calcOrdersPrefix(fromAssetID, toAssetID *bc.AssetID, utxoHash *bc.Hash, rate float64) []byte { | |
26 | + buf := make([]byte, 8) | |
27 | + binary.BigEndian.PutUint64(buf, math.Float64bits(rate)) | |
28 | + key := append(OrdersPreFix, fromAssetID.Bytes()...) | |
29 | + key = append(key, toAssetID.Bytes()...) | |
30 | + key = append(key, buf...) | |
31 | + return append(key, utxoHash.Bytes()...) | |
32 | +} | |
33 | + | |
34 | +func calcTradePairPreFix(fromAssetID, toAssetID *bc.Hash) []byte { | |
35 | + key := append(OrdersPreFix, fromAssetID.Bytes()...) | |
36 | + return append(key, toAssetID.Bytes()...) | |
37 | +} | |
38 | + | |
39 | +type DexTradeOrderDB struct { | |
40 | + db dbm.DB | |
41 | +} | |
42 | + | |
43 | +func (d *DexTradeOrderDB) GetTradePairsWithStart(start []byte) []dex.TradePair { | |
44 | + return nil | |
45 | +} | |
46 | + | |
47 | +func (d *DexTradeOrderDB) addTradePair() { | |
48 | + | |
49 | +} | |
50 | + | |
51 | +func (d *DexTradeOrderDB) deleteTradePair() { | |
52 | + | |
53 | +} | |
54 | + | |
55 | +func (d *DexTradeOrderDB) ProcessOrders(orders []dex.Order, delOreders []dex.Order, height uint64, blockHash *bc.Hash) { | |
56 | + | |
57 | +} | |
58 | + | |
59 | +func (d *DexTradeOrderDB) addOrders(orders []dex.Order) { | |
60 | + | |
61 | +} | |
62 | + | |
63 | +func (d *DexTradeOrderDB) deleteOrder(orders []dex.Order) { | |
64 | + | |
65 | +} | |
66 | + | |
67 | +func (d *DexTradeOrderDB) ListOrders(fromAssetID, toAssetID string, rateAfter float64) []dex.Order { | |
68 | + return nil | |
69 | +} | |
70 | + | |
71 | +func (d *DexTradeOrderDB) GetMatchState() *dex.MatchState { | |
72 | + return nil | |
73 | +} | |
74 | + | |
75 | +func (d *DexTradeOrderDB) SaveMatchState(state *dex.MatchState) { | |
76 | +} |
@@ -0,0 +1,28 @@ | ||
1 | +package dex | |
2 | + | |
3 | +import "github.com/vapor/protocol/bc" | |
4 | + | |
5 | +type DexUtxo struct { | |
6 | + SourceID bc.Hash | |
7 | + AssetID bc.AssetID | |
8 | + Amount uint64 | |
9 | + SourcePos uint64 | |
10 | + ControlProgram []byte | |
11 | +} | |
12 | + | |
13 | +type Order struct { | |
14 | + ToAssetID bc.AssetID | |
15 | + Rate float64 | |
16 | + Utxo DexUtxo | |
17 | +} | |
18 | + | |
19 | +type TradePair struct { | |
20 | + FromAssetID *bc.AssetID | |
21 | + ToAssetID *bc.AssetID | |
22 | + Count uint64 | |
23 | +} | |
24 | + | |
25 | +type MatchState struct { | |
26 | + Height uint64 | |
27 | + Hash *bc.Hash | |
28 | +} |