atomicswap_test.gno

  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(cur realm, 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 := NewCustomCoinSwap(cross, 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, Render("1"))
 86}
 87
 88func TestNewCustomCoinSwap_Refund(cur realm, 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 := NewCustomCoinSwap(cross, 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, 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 := NewCustomGRC20Swap(cross, 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, 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, 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 := NewCustomGRC20Swap(cross, 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, 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, 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 := NewGRC20Swap(cross, 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, 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, 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
374	test20.PrivateLedger.Mint(sender, 100_000)
375	test20.PrivateLedger.Approve(sender, rlm, 70_000)
376
377	// Create a new swap
378	testing.SetRealm(std.NewUserRealm(sender))
379	id, swap := NewGRC20Swap(cross, recipient, hashlockHex, "gno.land/r/demo/tests/test20")
380	uassert.Equal(t, 1, id)
381
382	expected := `- status: active
383- sender: g1wdjkuer9wgm97h6lta047h6lta047h6ltj497r
384- recipient: g1wfjkx6tsd9jkuapkta047h6lta047h6lqyf9rv
385- amount: 70000TST
386- hashlock: 2bb80d537b1da3e38bd30361aa855686bde0eacd7162fef6a25fe97bf527a25b
387- timelock: 2009-02-20T23:31:30Z
388- remaining: 168h0m0s`
389	uassert.Equal(t, expected, swap.String())
390	uassert.Equal(t, expected, Render("1"))
391
392	// Test initial state
393	uassert.Equal(t, sender, swap.sender, "expected sender to match")
394	uassert.Equal(t, recipient, swap.recipient, "expected recipient to match")
395	bal := test20.Token.BalanceOf(sender)
396	uassert.Equal(t, bal, int64(30_000))
397	bal = test20.Token.BalanceOf(rlm)
398	uassert.Equal(t, bal, int64(70_000))
399	bal = test20.Token.BalanceOf(recipient)
400	uassert.Equal(t, bal, int64(0))
401
402	// Test Refund
403	crossThrough(std.NewCodeRealm("gno.land/r/atomicswap/test"), func() {
404		testing.IssueCoins(pkgAddr, std.Coins{{"ugnot", 100000000}})
405		uassert.PanicsWithMessage(t, "timelock not expired", swap.Refund)
406	})
407
408	swap.timelock = time.Now().Add(-1 * time.Hour) // override timelock
409	crossThrough(std.NewCodeRealm("gno.land/r/atomicswap/test"), func() {
410		swap.Refund()
411		uassert.True(t, swap.refunded, "expected refunded to be true")
412	})
413
414	bal = test20.Token.BalanceOf(sender)
415	uassert.Equal(t, bal, int64(100_000))
416	bal = test20.Token.BalanceOf(rlm)
417	uassert.Equal(t, bal, int64(0))
418	bal = test20.Token.BalanceOf(recipient)
419	uassert.Equal(t, bal, int64(0))
420
421	expected = `- status: refunded
422- sender: g1wdjkuer9wgm97h6lta047h6lta047h6ltj497r
423- recipient: g1wfjkx6tsd9jkuapkta047h6lta047h6lqyf9rv
424- amount: 70000TST
425- hashlock: 2bb80d537b1da3e38bd30361aa855686bde0eacd7162fef6a25fe97bf527a25b
426- timelock: 2009-02-13T22:31:30Z
427- remaining: 0s`
428	uassert.Equal(t, expected, swap.String())
429	uassert.Equal(t, expected, Render("1"))
430}
431
432func TestRender(t *testing.T) {
433	defer resetTestState()
434
435	// Setup
436	alice := testutils.TestAddress("alice")
437	bob := testutils.TestAddress("bob")
438	charly := testutils.TestAddress("charly")
439	rlm := std.DerivePkgAddr("gno.land/r/demo/atomicswap")
440	hashlock := sha256.Sum256([]byte("secret"))
441	hashlockHex := hex.EncodeToString(hashlock[:])
442	timelock := time.Now().Add(1 * time.Hour)
443
444	test20.PrivateLedger.Mint(alice, 100_000)
445	testing.SetRealm(std.NewUserRealm(alice))
446
447	userTeller := test20.Token.RealmTeller()
448	userTeller.Approve(rlm, 10_000)
449	_, bobSwap := NewCustomGRC20Swap(cross, bob, hashlockHex, timelock, test20.Token)
450
451	userTeller.Approve(rlm, 20_000)
452	_, _ = NewCustomGRC20Swap(cross, charly, hashlockHex, timelock, test20.Token)
453
454	testing.SetRealm(std.NewUserRealm(bob))
455	crossThrough(std.NewCodeRealm("gno.land/r/atomicswap/test"), func() {
456		bobSwap.Claim("secret")
457		expected := `- 2: g1v9kxjcm9ta047h6lta047h6lta047h6lzd40gh -(20000TST)> g1vd5xzunv09047h6lta047h6lta047h6lhsyveh - active
458- 1: g1v9kxjcm9ta047h6lta047h6lta047h6lzd40gh -(10000TST)> g1vfhkyh6lta047h6lta047h6lta047h6l03vdhu - claimed
459`
460		uassert.Equal(t, expected, Render(""))
461	})
462}
463
464func resetTestState() {
465	swaps = avl.Tree{}
466	counter = 0
467}