txio/src/wallet/aptos.test.ts at fix/aptos-silent-restore · ghzhost/txio · GitHub

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
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { connectAptosWallet, restoreAptosWallet } from './aptos';

describe('Aptos Wallet', () => {
    beforeEach(() => {
        vi.clearAllMocks();
        // @ts-expect-error test double
        delete window.aptos;
        // @ts-expect-error test double
        delete window.martian;
    });

    afterEach(() => {
        vi.useRealTimers();
    });

    describe('connectAptosWallet', () => {
        it('connects Petra when provider is present', async () => {
            // @ts-expect-error test double
            window.aptos = {
                connect: vi.fn().mockResolvedValue({ address: '0xpetra123' })
            };

            const wallet = await connectAptosWallet('petra');
            expect(wallet).toMatchObject({
                id: 'petra',
                name: 'Petra',
                address: '0xpetra123',
                family: 'aptos'
            });
        });

        it('connects Martian when provider is present', async () => {
            // @ts-expect-error test double
            window.martian = {
                connect: vi.fn().mockResolvedValue({ address: '0xmartian456' })
            };

            const wallet = await connectAptosWallet('martian');
            expect(wallet).toMatchObject({
                id: 'martian',
                name: 'Martian',
                address: '0xmartian456',
                family: 'aptos'
            });
        });

        it('fails fast if wallet is not installed', async () => {
            await expect(connectAptosWallet('petra')).rejects.toThrow(
                /Petra is not installed/i
            );
        });

        it('rejects unsupported wallet ids', async () => {
            // @ts-expect-error intentional bad id
            await expect(connectAptosWallet('unknown-wallet')).rejects.toThrow(
                /not supported/i
            );
        });
    });

    describe('restoreAptosWallet (silent restoration)', () => {
        it('restores connected wallet silently when isConnected and account are available', async () => {
            // @ts-expect-error test double
            window.aptos = {
                isConnected: vi.fn().mockResolvedValue(true),
                account: vi.fn().mockResolvedValue({ address: '0xpetra_restored' }),
                connect: vi.fn()
            };

            const wallet = await restoreAptosWallet('petra');
            expect(wallet).toMatchObject({
                id: 'petra',
                address: '0xpetra_restored',
                family: 'aptos'
            });
            expect(window.aptos.connect).not.toHaveBeenCalled();
        });

        it('returns null if isConnected returns false', async () => {
            // @ts-expect-error test double
            window.aptos = {
                isConnected: vi.fn().mockResolvedValue(false),
                account: vi.fn(),
                connect: vi.fn()
            };

            const wallet = await restoreAptosWallet('petra');
            expect(wallet).toBeNull();
            expect(window.aptos.connect).not.toHaveBeenCalled();
        });

        it('returns null and NEVER calls connect() if silent check is unavailable', async () => {
            const connectMock = vi.fn().mockResolvedValue({ address: '0xpopup_address' });
            // @ts-expect-error test double: provider only exposes connect, no isConnected / account
            window.aptos = {
                connect: connectMock
            };

            const wallet = await restoreAptosWallet('petra');
            expect(wallet).toBeNull();
            expect(connectMock).not.toHaveBeenCalled();
        });

        it('returns null when provider is missing', async () => {
            const wallet = await restoreAptosWallet('petra');
            expect(wallet).toBeNull();
        });
    });
});