atomicswap_test.gno
16.58 Kb ยท 468 lines
1package atomicswap
2
3import (
4 "crypto/sha256"
5 "encoding/hex"
6 "std"
7 "testing"
8 "time"
9
10 "gno.land/p/demo/avl"
11 "gno.land/p/demo/testutils"
12 "gno.land/p/demo/uassert"
13 "gno.land/r/demo/tests/test20"
14)
15
16var testRun bool
17
18func crossThrough(rlm std.Realm, cr func()) {
19 testing.SetRealm(rlm)
20 cr()
21}
22
23func TestNewCustomCoinSwap_Claim(t *testing.T) {
24 defer resetTestState()
25
26 // Setup
27 pkgAddr := std.DerivePkgAddr("gno.land/r/demo/atomicswap")
28 sender := testutils.TestAddress("sender1")
29 recipient := testutils.TestAddress("recipient1")
30 amount := std.Coins{{Denom: "ugnot", Amount: 1}}
31 hashlock := sha256.Sum256([]byte("secret"))
32 hashlockHex := hex.EncodeToString(hashlock[:])
33 timelock := time.Now().Add(1 * time.Hour)
34 testing.IssueCoins(pkgAddr, std.Coins{{"ugnot", 100000000}})
35
36 // Create a new swap
37 testing.SetRealm(std.NewUserRealm(sender))
38 testing.SetOriginSend(amount)
39 id, swap := cross(NewCustomCoinSwap)(recipient, hashlockHex, timelock)
40 uassert.Equal(t, 1, id)
41
42 expected := `- status: active
43- sender: g1wdjkuer9wgc47h6lta047h6lta047h6l56jtjc
44- recipient: g1wfjkx6tsd9jkuap3ta047h6lta047h6lkk20gv
45- amount: 1ugnot
46- hashlock: 2bb80d537b1da3e38bd30361aa855686bde0eacd7162fef6a25fe97bf527a25b
47- timelock: 2009-02-14T00:31:30Z
48- remaining: 1h0m0s`
49 uassert.Equal(t, expected, swap.String())
50 uassert.Equal(t, expected, Render("1"))
51
52 // Test initial state
53 uassert.Equal(t, sender, swap.sender, "expected sender to match")
54 uassert.Equal(t, recipient, swap.recipient, "expected recipient to match")
55 uassert.Equal(t, swap.amountStr, amount.String(), "expected amount to match")
56 uassert.Equal(t, hashlockHex, swap.hashlock, "expected hashlock to match")
57 uassert.True(t, swap.timelock.Equal(timelock), "expected timelock to match")
58 uassert.False(t, swap.claimed, "expected claimed to be false")
59 uassert.False(t, swap.refunded, "expected refunded to be false")
60
61 // Test claim
62 testing.SetRealm(std.NewUserRealm(recipient))
63 crossThrough(std.NewCodeRealm("gno.land/r/atomicswap/test"), func() {
64 uassert.PanicsWithMessage(t, "invalid preimage", func() { swap.Claim("invalid") })
65 })
66
67 testing.SetRealm(std.NewUserRealm(recipient))
68 crossThrough(std.NewCodeRealm("gno.land/r/atomicswap/test"), func() {
69 swap.Claim("secret")
70 uassert.True(t, swap.claimed, "expected claimed to be true")
71 })
72
73 // Test refund (should fail because already claimed)
74 uassert.PanicsWithMessage(t, "already claimed", swap.Refund)
75 uassert.PanicsWithMessage(t, "already claimed", func() { swap.Claim("secret") })
76
77 expected = `- status: claimed
78- sender: g1wdjkuer9wgc47h6lta047h6lta047h6l56jtjc
79- recipient: g1wfjkx6tsd9jkuap3ta047h6lta047h6lkk20gv
80- amount: 1ugnot
81- hashlock: 2bb80d537b1da3e38bd30361aa855686bde0eacd7162fef6a25fe97bf527a25b
82- timelock: 2009-02-14T00:31:30Z
83- remaining: 1h0m0s`
84 uassert.Equal(t, expected, swap.String())
85 uassert.Equal(t, expected, cross(Render)("1"))
86}
87
88func TestNewCustomCoinSwap_Refund(t *testing.T) {
89 defer resetTestState()
90
91 // Setup
92 pkgAddr := std.DerivePkgAddr("gno.land/r/demo/atomicswap")
93 sender := testutils.TestAddress("sender2")
94 recipient := testutils.TestAddress("recipient2")
95 amount := std.Coins{{Denom: "ugnot", Amount: 1}}
96 hashlock := sha256.Sum256([]byte("secret"))
97 hashlockHex := hex.EncodeToString(hashlock[:])
98 timelock := time.Now().Add(1 * time.Hour)
99
100 // Create a new swap
101 testing.SetRealm(std.NewUserRealm(sender))
102 testing.SetOriginSend(amount)
103 id, swap := cross(NewCustomCoinSwap)(recipient, hashlockHex, timelock) // Create a new swap
104 uassert.Equal(t, 1, id)
105
106 expected := `- status: active
107- sender: g1wdjkuer9wge97h6lta047h6lta047h6ltfacad
108- recipient: g1wfjkx6tsd9jkuapjta047h6lta047h6lducc3v
109- amount: 1ugnot
110- hashlock: 2bb80d537b1da3e38bd30361aa855686bde0eacd7162fef6a25fe97bf527a25b
111- timelock: 2009-02-14T00:31:30Z
112- remaining: 1h0m0s`
113 uassert.Equal(t, expected, swap.String())
114 uassert.Equal(t, expected, Render("1"))
115
116 // Test Refund
117 //testing.SetRealm(std.NewUserRealm(recipient))
118 crossThrough(std.NewCodeRealm("gno.land/r/atomicswap/test"), func() {
119 testing.IssueCoins(pkgAddr, std.Coins{{"ugnot", 100000000}})
120 uassert.PanicsWithMessage(t, "timelock not expired", swap.Refund)
121 })
122 swap.timelock = time.Now().Add(-1 * time.Hour) // override timelock
123 crossThrough(std.NewCodeRealm("gno.land/r/atomicswap/test"), func() {
124 swap.Refund()
125 uassert.True(t, swap.refunded, "expected refunded to be true")
126 })
127 expected = `- status: refunded
128- sender: g1wdjkuer9wge97h6lta047h6lta047h6ltfacad
129- recipient: g1wfjkx6tsd9jkuapjta047h6lta047h6lducc3v
130- amount: 1ugnot
131- hashlock: 2bb80d537b1da3e38bd30361aa855686bde0eacd7162fef6a25fe97bf527a25b
132- timelock: 2009-02-13T22:31:30Z
133- remaining: 0s`
134 uassert.Equal(t, expected, swap.String())
135 uassert.Equal(t, expected, cross(Render)("1"))
136}
137
138func TestNewCustomGRC20Swap_Claim(t *testing.T) {
139 defer resetTestState()
140
141 // Setup
142 sender := testutils.TestAddress("sender3")
143 recipient := testutils.TestAddress("recipient3")
144 rlm := std.DerivePkgAddr("gno.land/r/demo/atomicswap")
145 hashlock := sha256.Sum256([]byte("secret"))
146 hashlockHex := hex.EncodeToString(hashlock[:])
147 timelock := time.Now().Add(1 * time.Hour)
148
149 test20.PrivateLedger.Mint(sender, 100_000)
150 test20.PrivateLedger.Approve(sender, rlm, 70_000)
151
152 // Create a new swap
153 testing.SetRealm(std.NewUserRealm(sender))
154 id, swap := cross(NewCustomGRC20Swap)(recipient, hashlockHex, timelock, test20.Token)
155 uassert.Equal(t, 1, id)
156
157 expected := `- status: active
158- sender: g1wdjkuer9wge47h6lta047h6lta047h6l5rk38l
159- recipient: g1wfjkx6tsd9jkuapnta047h6lta047h6ly6k4pv
160- amount: 70000TST
161- hashlock: 2bb80d537b1da3e38bd30361aa855686bde0eacd7162fef6a25fe97bf527a25b
162- timelock: 2009-02-14T00:31:30Z
163- remaining: 1h0m0s`
164
165 uassert.Equal(t, expected, swap.String())
166 uassert.Equal(t, expected, cross(Render)("1"))
167
168 // Test initial state
169 uassert.Equal(t, sender, swap.sender, "expected sender to match")
170 uassert.Equal(t, recipient, swap.recipient, "expected recipient to match")
171 bal := test20.Token.BalanceOf(sender)
172 uassert.Equal(t, bal, int64(30_000))
173 bal = test20.Token.BalanceOf(rlm)
174 uassert.Equal(t, bal, int64(70_000))
175 bal = test20.Token.BalanceOf(recipient)
176 uassert.Equal(t, bal, int64(0))
177
178 // uassert.Equal(t, swap.amountStr, amount.String(), "expected amount to match")
179 uassert.Equal(t, hashlockHex, swap.hashlock, "expected hashlock to match")
180 uassert.True(t, swap.timelock.Equal(timelock), "expected timelock to match")
181 uassert.False(t, swap.claimed, "expected claimed to be false")
182 uassert.False(t, swap.refunded, "expected refunded to be false")
183
184 // Test claim
185 testing.SetRealm(std.NewUserRealm(recipient))
186 crossThrough(std.NewCodeRealm("gno.land/r/atomicswap/test"), func() {
187 uassert.PanicsWithMessage(t, "invalid preimage", func() { swap.Claim("invalid") })
188 })
189
190 testing.SetRealm(std.NewUserRealm(recipient))
191 crossThrough(std.NewCodeRealm("gno.land/r/atomicswap/test"), func() {
192 swap.Claim("secret")
193 uassert.True(t, swap.claimed, "expected claimed to be true")
194 })
195
196 bal = test20.Token.BalanceOf(sender)
197 uassert.Equal(t, bal, int64(30_000))
198 bal = test20.Token.BalanceOf(rlm)
199 uassert.Equal(t, bal, int64(0))
200 bal = test20.Token.BalanceOf(recipient)
201 uassert.Equal(t, bal, int64(70_000))
202
203 // Test refund (should fail because already claimed)
204 uassert.PanicsWithMessage(t, "already claimed", swap.Refund)
205 uassert.PanicsWithMessage(t, "already claimed", func() { swap.Claim("secret") })
206
207 expected = `- status: claimed
208- sender: g1wdjkuer9wge47h6lta047h6lta047h6l5rk38l
209- recipient: g1wfjkx6tsd9jkuapnta047h6lta047h6ly6k4pv
210- amount: 70000TST
211- hashlock: 2bb80d537b1da3e38bd30361aa855686bde0eacd7162fef6a25fe97bf527a25b
212- timelock: 2009-02-14T00:31:30Z
213- remaining: 1h0m0s`
214 uassert.Equal(t, expected, swap.String())
215 uassert.Equal(t, expected, cross(Render)("1"))
216}
217
218func TestNewCustomGRC20Swap_Refund(t *testing.T) {
219 defer resetTestState()
220
221 // Setup
222 pkgAddr := std.DerivePkgAddr("gno.land/r/demo/atomicswap")
223 sender := testutils.TestAddress("sender5")
224 recipient := testutils.TestAddress("recipient5")
225 rlm := std.DerivePkgAddr("gno.land/r/demo/atomicswap")
226 hashlock := sha256.Sum256([]byte("secret"))
227 hashlockHex := hex.EncodeToString(hashlock[:])
228 timelock := time.Now().Add(1 * time.Hour)
229
230 test20.PrivateLedger.Mint(sender, 100_000)
231 test20.PrivateLedger.Approve(sender, rlm, 70_000)
232
233 // Create a new swap
234 testing.SetRealm(std.NewUserRealm(sender))
235 id, swap := cross(NewCustomGRC20Swap)(recipient, hashlockHex, timelock, test20.Token)
236 uassert.Equal(t, 1, id)
237
238 expected := `- status: active
239- sender: g1wdjkuer9wg647h6lta047h6lta047h6l5p6k3k
240- recipient: g1wfjkx6tsd9jkuap4ta047h6lta047h6lmwmj6v
241- amount: 70000TST
242- hashlock: 2bb80d537b1da3e38bd30361aa855686bde0eacd7162fef6a25fe97bf527a25b
243- timelock: 2009-02-14T00:31:30Z
244- remaining: 1h0m0s`
245 uassert.Equal(t, expected, swap.String())
246 uassert.Equal(t, expected, cross(Render)("1"))
247
248 // Test initial state
249 uassert.Equal(t, sender, swap.sender, "expected sender to match")
250 uassert.Equal(t, recipient, swap.recipient, "expected recipient to match")
251 bal := test20.Token.BalanceOf(sender)
252 uassert.Equal(t, bal, int64(30_000))
253 bal = test20.Token.BalanceOf(rlm)
254 uassert.Equal(t, bal, int64(70_000))
255 bal = test20.Token.BalanceOf(recipient)
256 uassert.Equal(t, bal, int64(0))
257
258 // Test Refund
259 crossThrough(std.NewCodeRealm("gno.land/r/atomicswap/test"), func() {
260 testing.IssueCoins(pkgAddr, std.Coins{{"ugnot", 100000000}})
261 uassert.PanicsWithMessage(t, "timelock not expired", swap.Refund)
262 })
263
264 swap.timelock = time.Now().Add(-1 * time.Hour) // override timelock
265 crossThrough(std.NewCodeRealm("gno.land/r/atomicswap/test"), func() {
266 swap.Refund()
267 uassert.True(t, swap.refunded, "expected refunded to be true")
268 })
269
270 bal = test20.Token.BalanceOf(sender)
271 uassert.Equal(t, bal, int64(100_000))
272 bal = test20.Token.BalanceOf(rlm)
273 uassert.Equal(t, bal, int64(0))
274 bal = test20.Token.BalanceOf(recipient)
275 uassert.Equal(t, bal, int64(0))
276
277 expected = `- status: refunded
278- sender: g1wdjkuer9wg647h6lta047h6lta047h6l5p6k3k
279- recipient: g1wfjkx6tsd9jkuap4ta047h6lta047h6lmwmj6v
280- amount: 70000TST
281- hashlock: 2bb80d537b1da3e38bd30361aa855686bde0eacd7162fef6a25fe97bf527a25b
282- timelock: 2009-02-13T22:31:30Z
283- remaining: 0s`
284 uassert.Equal(t, expected, swap.String())
285 uassert.Equal(t, expected, cross(Render)("1"))
286}
287
288func TestNewGRC20Swap_Claim(t *testing.T) {
289 defer resetTestState()
290
291 // Setup
292 sender := testutils.TestAddress("sender4")
293 recipient := testutils.TestAddress("recipient4")
294 rlm := std.DerivePkgAddr("gno.land/r/demo/atomicswap")
295 hashlock := sha256.Sum256([]byte("secret"))
296 hashlockHex := hex.EncodeToString(hashlock[:])
297 timelock := time.Now().Add(defaultTimelockDuration)
298
299 test20.PrivateLedger.Mint(sender, 100_000)
300 test20.PrivateLedger.Approve(sender, rlm, 70_000)
301
302 // Create a new swap
303 testing.SetRealm(std.NewUserRealm(sender))
304 id, swap := cross(NewGRC20Swap)(recipient, hashlockHex, "gno.land/r/demo/tests/test20")
305 uassert.Equal(t, 1, id)
306
307 expected := `- status: active
308- sender: g1wdjkuer9wg697h6lta047h6lta047h6ltt3lty
309- recipient: g1wfjkx6tsd9jkuap5ta047h6lta047h6ljg4l2v
310- amount: 70000TST
311- hashlock: 2bb80d537b1da3e38bd30361aa855686bde0eacd7162fef6a25fe97bf527a25b
312- timelock: 2009-02-20T23:31:30Z
313- remaining: 168h0m0s`
314 uassert.Equal(t, expected, swap.String())
315 uassert.Equal(t, expected, cross(Render)("1"))
316
317 // Test initial state
318 uassert.Equal(t, sender, swap.sender, "expected sender to match")
319 uassert.Equal(t, recipient, swap.recipient, "expected recipient to match")
320 bal := test20.Token.BalanceOf(sender)
321 uassert.Equal(t, bal, int64(30_000))
322 bal = test20.Token.BalanceOf(rlm)
323 uassert.Equal(t, bal, int64(70_000))
324 bal = test20.Token.BalanceOf(recipient)
325 uassert.Equal(t, bal, int64(0))
326
327 // uassert.Equal(t, swap.amountStr, amount.String(), "expected amount to match")
328 uassert.Equal(t, hashlockHex, swap.hashlock, "expected hashlock to match")
329 uassert.True(t, swap.timelock.Equal(timelock), "expected timelock to match")
330 uassert.False(t, swap.claimed, "expected claimed to be false")
331 uassert.False(t, swap.refunded, "expected refunded to be false")
332
333 // Test claim
334 testing.SetRealm(std.NewUserRealm(recipient))
335 crossThrough(std.NewCodeRealm("gno.land/r/atomicswap/test"), func() {
336 uassert.PanicsWithMessage(t, "invalid preimage", func() { swap.Claim("invalid") })
337 swap.Claim("secret")
338 uassert.True(t, swap.claimed, "expected claimed to be true")
339 })
340
341 bal = test20.Token.BalanceOf(sender)
342 uassert.Equal(t, int64(30_000), bal)
343 bal = test20.Token.BalanceOf(rlm)
344 uassert.Equal(t, int64(0), bal)
345 bal = test20.Token.BalanceOf(recipient)
346 uassert.Equal(t, int64(70_000), bal)
347
348 // Test refund (should fail because already claimed)
349 uassert.PanicsWithMessage(t, "already claimed", swap.Refund)
350 uassert.PanicsWithMessage(t, "already claimed", func() { swap.Claim("secret") })
351
352 expected = `- status: claimed
353- sender: g1wdjkuer9wg697h6lta047h6lta047h6ltt3lty
354- recipient: g1wfjkx6tsd9jkuap5ta047h6lta047h6ljg4l2v
355- amount: 70000TST
356- hashlock: 2bb80d537b1da3e38bd30361aa855686bde0eacd7162fef6a25fe97bf527a25b
357- timelock: 2009-02-20T23:31:30Z
358- remaining: 168h0m0s`
359 uassert.Equal(t, expected, swap.String())
360 uassert.Equal(t, expected, cross(Render)("1"))
361}
362
363func TestNewGRC20Swap_Refund(t *testing.T) {
364 defer resetTestState()
365
366 // Setup
367 pkgAddr := std.DerivePkgAddr("gno.land/r/demo/atomicswap")
368 sender := testutils.TestAddress("sender6")
369 recipient := testutils.TestAddress("recipient6")
370 rlm := std.DerivePkgAddr("gno.land/r/demo/atomicswap")
371 hashlock := sha256.Sum256([]byte("secret"))
372 hashlockHex := hex.EncodeToString(hashlock[:])
373 timelock := time.Now().Add(defaultTimelockDuration)
374
375 test20.PrivateLedger.Mint(sender, 100_000)
376 test20.PrivateLedger.Approve(sender, rlm, 70_000)
377
378 // Create a new swap
379 testing.SetRealm(std.NewUserRealm(sender))
380 id, swap := cross(NewGRC20Swap)(recipient, hashlockHex, "gno.land/r/demo/tests/test20")
381 uassert.Equal(t, 1, id)
382
383 expected := `- status: active
384- sender: g1wdjkuer9wgm97h6lta047h6lta047h6ltj497r
385- recipient: g1wfjkx6tsd9jkuapkta047h6lta047h6lqyf9rv
386- amount: 70000TST
387- hashlock: 2bb80d537b1da3e38bd30361aa855686bde0eacd7162fef6a25fe97bf527a25b
388- timelock: 2009-02-20T23:31:30Z
389- remaining: 168h0m0s`
390 uassert.Equal(t, expected, swap.String())
391 uassert.Equal(t, expected, cross(Render)("1"))
392
393 // Test initial state
394 uassert.Equal(t, sender, swap.sender, "expected sender to match")
395 uassert.Equal(t, recipient, swap.recipient, "expected recipient to match")
396 bal := test20.Token.BalanceOf(sender)
397 uassert.Equal(t, bal, int64(30_000))
398 bal = test20.Token.BalanceOf(rlm)
399 uassert.Equal(t, bal, int64(70_000))
400 bal = test20.Token.BalanceOf(recipient)
401 uassert.Equal(t, bal, int64(0))
402
403 // Test Refund
404 crossThrough(std.NewCodeRealm("gno.land/r/atomicswap/test"), func() {
405 testing.IssueCoins(pkgAddr, std.Coins{{"ugnot", 100000000}})
406 uassert.PanicsWithMessage(t, "timelock not expired", swap.Refund)
407 })
408
409 swap.timelock = time.Now().Add(-1 * time.Hour) // override timelock
410 crossThrough(std.NewCodeRealm("gno.land/r/atomicswap/test"), func() {
411 swap.Refund()
412 uassert.True(t, swap.refunded, "expected refunded to be true")
413 })
414
415 bal = test20.Token.BalanceOf(sender)
416 uassert.Equal(t, bal, int64(100_000))
417 bal = test20.Token.BalanceOf(rlm)
418 uassert.Equal(t, bal, int64(0))
419 bal = test20.Token.BalanceOf(recipient)
420 uassert.Equal(t, bal, int64(0))
421
422 expected = `- status: refunded
423- sender: g1wdjkuer9wgm97h6lta047h6lta047h6ltj497r
424- recipient: g1wfjkx6tsd9jkuapkta047h6lta047h6lqyf9rv
425- amount: 70000TST
426- hashlock: 2bb80d537b1da3e38bd30361aa855686bde0eacd7162fef6a25fe97bf527a25b
427- timelock: 2009-02-13T22:31:30Z
428- remaining: 0s`
429 uassert.Equal(t, expected, swap.String())
430 uassert.Equal(t, expected, cross(Render)("1"))
431}
432
433func TestRender(t *testing.T) {
434 defer resetTestState()
435
436 // Setup
437 alice := testutils.TestAddress("alice")
438 bob := testutils.TestAddress("bob")
439 charly := testutils.TestAddress("charly")
440 rlm := std.DerivePkgAddr("gno.land/r/demo/atomicswap")
441 hashlock := sha256.Sum256([]byte("secret"))
442 hashlockHex := hex.EncodeToString(hashlock[:])
443 timelock := time.Now().Add(1 * time.Hour)
444
445 test20.PrivateLedger.Mint(alice, 100_000)
446 testing.SetRealm(std.NewUserRealm(alice))
447
448 userTeller := test20.Token.RealmTeller()
449 userTeller.Approve(rlm, 10_000)
450 _, bobSwap := cross(NewCustomGRC20Swap)(bob, hashlockHex, timelock, test20.Token)
451
452 userTeller.Approve(rlm, 20_000)
453 _, _ = cross(NewCustomGRC20Swap)(charly, hashlockHex, timelock, test20.Token)
454
455 testing.SetRealm(std.NewUserRealm(bob))
456 crossThrough(std.NewCodeRealm("gno.land/r/atomicswap/test"), func() {
457 bobSwap.Claim("secret")
458 expected := `- 2: g1v9kxjcm9ta047h6lta047h6lta047h6lzd40gh -(20000TST)> g1vd5xzunv09047h6lta047h6lta047h6lhsyveh - active
459- 1: g1v9kxjcm9ta047h6lta047h6lta047h6lzd40gh -(10000TST)> g1vfhkyh6lta047h6lta047h6lta047h6l03vdhu - claimed
460`
461 uassert.Equal(t, expected, cross(Render)(""))
462 })
463}
464
465func resetTestState() {
466 swaps = avl.Tree{}
467 counter = 0
468}