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