walletpair-sdk 1.0.2 → 1.0.5

package/src/integration.test.ts

@@ -11,28 +11,33 @@
  *   7. Close
  */
 
-import { describe, it, expect, vi } from 'vitest';
-import { DAppSession } from './dapp-session.js';
-import { WalletSession } from './wallet-session.js';
-import { MockTransport, MockRelay, parseSnapshot } from './test-helpers.js';
-import { parsePairingUri } from './crypto.js';
+import { describe, expect, it, vi } from 'vitest'
+import { parsePairingUri } from './crypto.js'
+import { DAppSession } from './dapp-session.js'
+import { MockRelay, MockTransport, parseSnapshot } from './test-helpers.js'
+import { WalletSession } from './wallet-session.js'
 
 function wait(ms = 50): Promise<void> {
-  return new Promise((r) => setTimeout(r, ms));
+  return new Promise((r) => setTimeout(r, ms))
 }
 
 describe('Integration: DApp ↔ Wallet full flow', () => {
   it('completes full pairing and request/response cycle', async () => {
     // Setup transports + relay
-    const dappTransport = new MockTransport();
-    const walletTransport = new MockTransport();
-    const _relay = new MockRelay(dappTransport, walletTransport);
+    const dappTransport = new MockTransport()
+    const walletTransport = new MockTransport()
+    const _relay = new MockRelay(dappTransport, walletTransport)
 
     // Create sessions
     const dappSession = new DAppSession({
       transport: dappTransport,
-      meta: { name: 'Test dApp', description: 'Test', url: 'https://test.com', icon: 'https://test.com/icon.png' },
-    });
+      meta: {
+        name: 'Test dApp',
+        description: 'Test',
+        url: 'https://test.com',
+        icon: 'https://test.com/icon.png',
+      },
+    })
 
     const walletSession = new WalletSession({
       transport: walletTransport,
@@ -41,345 +46,468 @@ describe('Integration: DApp ↔ Wallet full flow', () => {
         events: ['accountsChanged'],
         chains: ['eip155:1'],
       },
-      meta: { name: 'Test Wallet', description: 'Test', url: 'https://test.com', icon: 'https://test.com/icon.png', address: '0xWalletAddr' },
-    });
+      meta: {
+        name: 'Test Wallet',
+        description: 'Test',
+        url: 'https://test.com',
+        icon: 'https://test.com/icon.png',
+        address: '0xWalletAddr',
+      },
+    })
 
     // Track events
-    const dappPhases: string[] = [];
-    const walletPhases: string[] = [];
-    dappSession.on('phase', (p) => dappPhases.push(p));
-    walletSession.on('phase', (p) => walletPhases.push(p));
+    const dappPhases: string[] = []
+    const walletPhases: string[] = []
+    dappSession.on('phase', (p) => dappPhases.push(p))
+    walletSession.on('phase', (p) => walletPhases.push(p))
 
     // Step 1: DApp creates pairing
-    const pairingUri = await dappSession.createPairing();
-    expect(pairingUri).toContain('walletpair:?ch=');
-    await wait();
-    expect(dappSession.phase).toBe('waiting');
+    const pairingUri = await dappSession.createPairing()
+    expect(pairingUri).toContain('walletpair:?ch=')
+    await wait()
+    expect(dappSession.phase).toBe('waiting')
 
     // Step 2: Wallet joins
     // Need to set the walletTransport URL from the pairing URI
-    const parsed = parsePairingUri(pairingUri);
+    const _parsed = parsePairingUri(pairingUri)
     if ('setUrl' in walletTransport) {
-      (walletTransport as any).setUrl = () => {}; // mock
+      ;(walletTransport as any).setUrl = () => {} // mock
     }
 
-    const sessionFingerprint = await walletSession.joinFromUri(pairingUri);
-    await wait();
+    const sessionFingerprint = await walletSession.joinFromUri(pairingUri)
+    await wait()
 
-    expect(sessionFingerprint).toMatch(/^\d{4}$/);
+    expect(sessionFingerprint).toMatch(/^\d{4}$/)
 
     // Step 3: Session fingerprints match
-    expect(dappSession.sessionFingerprint).toBe(walletSession.sessionFingerprint);
+    expect(dappSession.sessionFingerprint).toBe(walletSession.sessionFingerprint)
 
     // Verify wallet capabilities were received
-    expect(dappSession.walletCapabilities?.methods).toContain('wallet_getAccounts');
-    expect(dappSession.walletMeta?.name).toBe('Test Wallet');
+    expect(dappSession.walletCapabilities?.methods).toContain('wallet_getAccounts')
+    expect(dappSession.walletMeta?.name).toBe('Test Wallet')
 
     // Step 4: DApp auto-accepts (no manual acceptWallet needed)
-    await wait();
+    await wait()
 
-    expect(dappSession.phase).toBe('connected');
-    expect(walletSession.phase).toBe('connected');
+    expect(dappSession.phase).toBe('connected')
+    expect(walletSession.phase).toBe('connected')
 
     // Step 5: DApp sends request → wallet responds
     walletSession.on('request', ({ id, method, params }) => {
       if (method === 'wallet_getAccounts') {
-        walletSession.approve(id, ['0xWalletAddr']);
+        walletSession.approve(id, ['0xWalletAddr'])
       }
-    });
+    })
 
-    const accounts = await dappSession.request('wallet_getAccounts');
-    expect(accounts).toEqual(['0xWalletAddr']);
+    const accounts = await dappSession.request('wallet_getAccounts')
+    expect(accounts).toEqual(['0xWalletAddr'])
 
     // Step 6: Wallet pushes event → dApp receives
-    const eventHandler = vi.fn();
-    dappSession.on('event', eventHandler);
+    const eventHandler = vi.fn()
+    dappSession.on('event', eventHandler)
 
-    walletSession.pushEvent('accountsChanged', { accounts: ['0xNewAddr'] });
-    await wait();
+    walletSession.pushEvent('accountsChanged', { accounts: ['0xNewAddr'] })
+    await wait()
 
     expect(eventHandler).toHaveBeenCalledWith({
       event: 'accountsChanged',
       data: { accounts: ['0xNewAddr'] },
-    });
+    })
 
     // Step 7: Close
-    dappSession.close();
-    expect(dappSession.phase).toBe('closed');
+    dappSession.close()
+    expect(dappSession.phase).toBe('closed')
 
     // Verify phase transitions
-    expect(dappPhases).toContain('waiting');
-    expect(dappPhases).toContain('connected');
-    expect(dappPhases).toContain('closed');
+    expect(dappPhases).toContain('waiting')
+    expect(dappPhases).toContain('connected')
+    expect(dappPhases).toContain('closed')
 
-    expect(walletPhases).toContain('waiting_accept');
-    expect(walletPhases).toContain('connected');
-  });
+    expect(walletPhases).toContain('waiting_accept')
+    expect(walletPhases).toContain('connected')
+  })
 
   it('wallet rejects request', async () => {
-    const dappTransport = new MockTransport();
-    const walletTransport = new MockTransport();
-    const _relay = new MockRelay(dappTransport, walletTransport);
+    const dappTransport = new MockTransport()
+    const walletTransport = new MockTransport()
+    const _relay = new MockRelay(dappTransport, walletTransport)
 
-    const dappSession = new DAppSession({ transport: dappTransport, meta: { name: 'Test dApp', description: 'Test', url: 'https://test.com', icon: 'https://test.com/icon.png' } });
+    const dappSession = new DAppSession({
+      transport: dappTransport,
+      meta: {
+        name: 'Test dApp',
+        description: 'Test',
+        url: 'https://test.com',
+        icon: 'https://test.com/icon.png',
+      },
+    })
     const walletSession = new WalletSession({
       transport: walletTransport,
       capabilities: { methods: ['wallet_signMessage'], events: [], chains: ['eip155:1'] },
-      meta: { name: 'Test Wallet', description: 'Test', url: 'https://test.com', icon: 'https://test.com/icon.png' },
-    });
+      meta: {
+        name: 'Test Wallet',
+        description: 'Test',
+        url: 'https://test.com',
+        icon: 'https://test.com/icon.png',
+      },
+    })
 
     // Connect (auto-accept)
-    const uri = await dappSession.createPairing();
-    await walletSession.joinFromUri(uri);
-    await wait();
-    await wait();
+    const uri = await dappSession.createPairing()
+    await walletSession.joinFromUri(uri)
+    await wait()
+    await wait()
 
     // Wallet rejects
     walletSession.on('request', ({ id }) => {
-      walletSession.reject(id, 'user_rejected', 'No thanks');
-    });
+      walletSession.reject(id, 'user_rejected', 'No thanks')
+    })
 
-    await expect(dappSession.request('wallet_signMessage', { message: 'hi' }))
-      .rejects.toThrow('No thanks');
-  });
+    await expect(dappSession.request('wallet_signMessage', { message: 'hi' })).rejects.toThrow(
+      'No thanks',
+    )
+  })
 
   it('multiple sequential requests', async () => {
-    const dappTransport = new MockTransport();
-    const walletTransport = new MockTransport();
-    const _relay = new MockRelay(dappTransport, walletTransport);
+    const dappTransport = new MockTransport()
+    const walletTransport = new MockTransport()
+    const _relay = new MockRelay(dappTransport, walletTransport)
 
-    const dappSession = new DAppSession({ transport: dappTransport, meta: { name: 'Test dApp', description: 'Test', url: 'https://test.com', icon: 'https://test.com/icon.png' } });
+    const dappSession = new DAppSession({
+      transport: dappTransport,
+      meta: {
+        name: 'Test dApp',
+        description: 'Test',
+        url: 'https://test.com',
+        icon: 'https://test.com/icon.png',
+      },
+    })
     const walletSession = new WalletSession({
       transport: walletTransport,
       capabilities: { methods: ['wallet_getAccounts'], events: [], chains: ['eip155:1'] },
-      meta: { name: 'Test Wallet', description: 'Test', url: 'https://test.com', icon: 'https://test.com/icon.png' },
-    });
+      meta: {
+        name: 'Test Wallet',
+        description: 'Test',
+        url: 'https://test.com',
+        icon: 'https://test.com/icon.png',
+      },
+    })
 
-    const uri = await dappSession.createPairing();
-    await walletSession.joinFromUri(uri);
-    await wait();
-    await wait();
+    const uri = await dappSession.createPairing()
+    await walletSession.joinFromUri(uri)
+    await wait()
+    await wait()
 
-    let callCount = 0;
+    let callCount = 0
     walletSession.on('request', ({ id, method }) => {
-      callCount++;
-      walletSession.approve(id, { call: callCount });
-    });
+      callCount++
+      walletSession.approve(id, { call: callCount })
+    })
 
-    const r1 = await dappSession.request('wallet_getAccounts');
-    const r2 = await dappSession.request('wallet_getAccounts');
-    const r3 = await dappSession.request('wallet_getAccounts');
+    const r1 = await dappSession.request('wallet_getAccounts')
+    const r2 = await dappSession.request('wallet_getAccounts')
+    const r3 = await dappSession.request('wallet_getAccounts')
 
-    expect(r1).toEqual({ call: 1 });
-    expect(r2).toEqual({ call: 2 });
-    expect(r3).toEqual({ call: 3 });
-  });
-});
+    expect(r1).toEqual({ call: 1 })
+    expect(r2).toEqual({ call: 2 })
+    expect(r3).toEqual({ call: 3 })
+  })
+})
 
 // ---------------------------------------------------------------------------
 // Directional key integration tests
 // ---------------------------------------------------------------------------
 
 describe('Integration: Bidirectional flow with directional keys', () => {
-
   it('full bidirectional flow: dApp sends request, wallet receives, wallet responds, dApp receives', async () => {
-    const dappTransport = new MockTransport();
-    const walletTransport = new MockTransport();
-    const _relay = new MockRelay(dappTransport, walletTransport);
+    const dappTransport = new MockTransport()
+    const walletTransport = new MockTransport()
+    const _relay = new MockRelay(dappTransport, walletTransport)
 
-    const dappSession = new DAppSession({ transport: dappTransport, meta: { name: 'BiDi dApp', description: 'Test', url: 'https://test.com', icon: 'https://test.com/icon.png' } });
+    const dappSession = new DAppSession({
+      transport: dappTransport,
+      meta: {
+        name: 'BiDi dApp',
+        description: 'Test',
+        url: 'https://test.com',
+        icon: 'https://test.com/icon.png',
+      },
+    })
     const walletSession = new WalletSession({
       transport: walletTransport,
-      capabilities: { methods: ['wallet_getAccounts', 'wallet_signMessage'], events: ['accountsChanged'], chains: ['eip155:1'] },
-      meta: { name: 'BiDi Wallet', description: 'Test', url: 'https://test.com', icon: 'https://test.com/icon.png', address: '0xBiDi' },
-    });
+      capabilities: {
+        methods: ['wallet_getAccounts', 'wallet_signMessage'],
+        events: ['accountsChanged'],
+        chains: ['eip155:1'],
+      },
+      meta: {
+        name: 'BiDi Wallet',
+        description: 'Test',
+        url: 'https://test.com',
+        icon: 'https://test.com/icon.png',
+        address: '0xBiDi',
+      },
+    })
 
-    const uri = await dappSession.createPairing();
-    await walletSession.joinFromUri(uri);
-    await wait();
+    const uri = await dappSession.createPairing()
+    await walletSession.joinFromUri(uri)
+    await wait()
 
     // Verify session fingerprints match
-    expect(dappSession.sessionFingerprint).toBe(walletSession.sessionFingerprint);
+    expect(dappSession.sessionFingerprint).toBe(walletSession.sessionFingerprint)
 
-    await wait();
+    await wait()
 
-    expect(dappSession.phase).toBe('connected');
-    expect(walletSession.phase).toBe('connected');
+    expect(dappSession.phase).toBe('connected')
+    expect(walletSession.phase).toBe('connected')
 
     // Wallet handles requests
     walletSession.on('request', ({ id, method, params }) => {
       if (method === 'wallet_getAccounts') {
-        walletSession.approve(id, ['0xBiDi']);
+        walletSession.approve(id, ['0xBiDi'])
       } else if (method === 'wallet_signMessage') {
-        walletSession.approve(id, { signature: '0xSIG' });
+        walletSession.approve(id, { signature: '0xSIG' })
       }
-    });
+    })
 
     // DApp sends request (uses dappToWalletKey), wallet decrypts (uses dappToWalletKey as recvKey)
-    const accounts = await dappSession.request('wallet_getAccounts');
-    expect(accounts).toEqual(['0xBiDi']);
+    const accounts = await dappSession.request('wallet_getAccounts')
+    expect(accounts).toEqual(['0xBiDi'])
 
     // Wallet responds (uses walletToDappKey), dApp decrypts (uses walletToDappKey as recvKey)
-    const sig = await dappSession.request('wallet_signMessage', { message: 'test' });
-    expect(sig).toEqual({ signature: '0xSIG' });
-  });
+    const sig = await dappSession.request('wallet_signMessage', { message: 'test' })
+    expect(sig).toEqual({ signature: '0xSIG' })
+  })
 
   it('wallet pushes event, dApp receives with correct key', async () => {
-    const dappTransport = new MockTransport();
-    const walletTransport = new MockTransport();
-    const _relay = new MockRelay(dappTransport, walletTransport);
+    const dappTransport = new MockTransport()
+    const walletTransport = new MockTransport()
+    const _relay = new MockRelay(dappTransport, walletTransport)
 
-    const dappSession = new DAppSession({ transport: dappTransport, meta: { name: 'Test dApp', description: 'Test', url: 'https://test.com', icon: 'https://test.com/icon.png' } });
+    const dappSession = new DAppSession({
+      transport: dappTransport,
+      meta: {
+        name: 'Test dApp',
+        description: 'Test',
+        url: 'https://test.com',
+        icon: 'https://test.com/icon.png',
+      },
+    })
     const walletSession = new WalletSession({
       transport: walletTransport,
-      capabilities: { methods: ['wallet_getAccounts'], events: ['accountsChanged', 'chainChanged'], chains: ['eip155:1'] },
-      meta: { name: 'Test Wallet', description: 'Test', url: 'https://test.com', icon: 'https://test.com/icon.png' },
-    });
+      capabilities: {
+        methods: ['wallet_getAccounts'],
+        events: ['accountsChanged', 'chainChanged'],
+        chains: ['eip155:1'],
+      },
+      meta: {
+        name: 'Test Wallet',
+        description: 'Test',
+        url: 'https://test.com',
+        icon: 'https://test.com/icon.png',
+      },
+    })
 
-    const uri = await dappSession.createPairing();
-    await walletSession.joinFromUri(uri);
-    await wait();
-    await wait();
+    const uri = await dappSession.createPairing()
+    await walletSession.joinFromUri(uri)
+    await wait()
+    await wait()
 
-    const events: Array<{ event: string; data: unknown }> = [];
-    dappSession.on('event', (evt) => events.push(evt));
+    const events: Array<{ event: string; data: unknown }> = []
+    dappSession.on('event', (evt) => events.push(evt))
 
     // Push multiple events
-    walletSession.pushEvent('accountsChanged', { accounts: ['0xNew'] });
-    walletSession.pushEvent('chainChanged', { chainId: 'eip155:137' });
-    await wait();
+    walletSession.pushEvent('accountsChanged', { accounts: ['0xNew'] })
+    walletSession.pushEvent('chainChanged', { chainId: 'eip155:137' })
+    await wait()
 
-    expect(events).toHaveLength(2);
-    expect(events[0]).toEqual({ event: 'accountsChanged', data: { accounts: ['0xNew'] } });
-    expect(events[1]).toEqual({ event: 'chainChanged', data: { chainId: 'eip155:137' } });
-  });
+    expect(events).toHaveLength(2)
+    expect(events[0]).toEqual({ event: 'accountsChanged', data: { accounts: ['0xNew'] } })
+    expect(events[1]).toEqual({ event: 'chainChanged', data: { chainId: 'eip155:137' } })
+  })
 
   it('multiple concurrent requests do not interfere', async () => {
-    const dappTransport = new MockTransport();
-    const walletTransport = new MockTransport();
-    const _relay = new MockRelay(dappTransport, walletTransport);
+    const dappTransport = new MockTransport()
+    const walletTransport = new MockTransport()
+    const _relay = new MockRelay(dappTransport, walletTransport)
 
-    const dappSession = new DAppSession({ transport: dappTransport, meta: { name: 'Test dApp', description: 'Test', url: 'https://test.com', icon: 'https://test.com/icon.png' } });
+    const dappSession = new DAppSession({
+      transport: dappTransport,
+      meta: {
+        name: 'Test dApp',
+        description: 'Test',
+        url: 'https://test.com',
+        icon: 'https://test.com/icon.png',
+      },
+    })
     const walletSession = new WalletSession({
       transport: walletTransport,
-      capabilities: { methods: ['wallet_getAccounts', 'wallet_signMessage'], events: [], chains: ['eip155:1'] },
-      meta: { name: 'Test Wallet', description: 'Test', url: 'https://test.com', icon: 'https://test.com/icon.png' },
-    });
+      capabilities: {
+        methods: ['wallet_getAccounts', 'wallet_signMessage'],
+        events: [],
+        chains: ['eip155:1'],
+      },
+      meta: {
+        name: 'Test Wallet',
+        description: 'Test',
+        url: 'https://test.com',
+        icon: 'https://test.com/icon.png',
+      },
+    })
 
-    const uri = await dappSession.createPairing();
-    await walletSession.joinFromUri(uri);
-    await wait();
-    await wait();
+    const uri = await dappSession.createPairing()
+    await walletSession.joinFromUri(uri)
+    await wait()
+    await wait()
 
     // Wallet responds to each request with method-specific data, but with a delay
     walletSession.on('request', ({ id, method }) => {
       if (method === 'wallet_getAccounts') {
         // Respond immediately
-        walletSession.approve(id, ['0xABC']);
+        walletSession.approve(id, ['0xABC'])
       } else if (method === 'wallet_signMessage') {
         // Respond slightly delayed
-        setTimeout(() => walletSession.approve(id, '0xSIG123'), 10);
+        setTimeout(() => walletSession.approve(id, '0xSIG123'), 10)
       }
-    });
+    })
 
     // Fire both concurrently
     const [accounts, signature] = await Promise.all([
       dappSession.request('wallet_getAccounts'),
       dappSession.request('wallet_signMessage', { message: 'hello' }),
-    ]);
+    ])
 
-    expect(accounts).toEqual(['0xABC']);
-    expect(signature).toBe('0xSIG123');
-  });
+    expect(accounts).toEqual(['0xABC'])
+    expect(signature).toBe('0xSIG123')
+  })
 
   it('session serialization preserves directional keys', async () => {
-    const dappTransport = new MockTransport();
-    const walletTransport = new MockTransport();
-    const _relay = new MockRelay(dappTransport, walletTransport);
+    const dappTransport = new MockTransport()
+    const walletTransport = new MockTransport()
+    const _relay = new MockRelay(dappTransport, walletTransport)
 
-    const dappSession = new DAppSession({ transport: dappTransport, meta: { name: 'Persist dApp', description: 'Test', url: 'https://test.com', icon: 'https://test.com/icon.png' } });
+    const dappSession = new DAppSession({
+      transport: dappTransport,
+      meta: {
+        name: 'Persist dApp',
+        description: 'Test',
+        url: 'https://test.com',
+        icon: 'https://test.com/icon.png',
+      },
+    })
     const walletSession = new WalletSession({
       transport: walletTransport,
       capabilities: { methods: ['wallet_getAccounts'], events: [], chains: ['eip155:1'] },
-      meta: { name: 'Persist Wallet', description: 'Test', url: 'https://test.com', icon: 'https://test.com/icon.png' },
-    });
+      meta: {
+        name: 'Persist Wallet',
+        description: 'Test',
+        url: 'https://test.com',
+        icon: 'https://test.com/icon.png',
+      },
+    })
 
-    const uri = await dappSession.createPairing();
-    await walletSession.joinFromUri(uri);
-    await wait();
-    await wait();
+    const uri = await dappSession.createPairing()
+    await walletSession.joinFromUri(uri)
+    await wait()
+    await wait()
 
     // Serialize both sessions
-    const dappJson = dappSession.serialize();
-    const walletJson = walletSession.serialize();
+    const dappJson = dappSession.serialize()
+    const walletJson = walletSession.serialize()
 
     // Parse and verify directional keys are stored
-    const dappState = parseSnapshot(dappJson);
-    const walletState = parseSnapshot(walletJson);
+    const dappState = parseSnapshot(dappJson)
+    const walletState = parseSnapshot(walletJson)
 
-    expect(dappState.sendKey).toBeTruthy();
-    expect(dappState.recvKey).toBeTruthy();
-    expect(walletState.sendKey).toBeTruthy();
-    expect(walletState.recvKey).toBeTruthy();
+    expect(dappState.sendKey).toBeTruthy()
+    expect(dappState.recvKey).toBeTruthy()
+    expect(walletState.sendKey).toBeTruthy()
+    expect(walletState.recvKey).toBeTruthy()
 
     // DApp sendKey (dappToWalletKey) == Wallet recvKey (dappToWalletKey)
-    expect(dappState.sendKey).toBe(walletState.recvKey);
+    expect(dappState.sendKey).toBe(walletState.recvKey)
     // DApp recvKey (walletToDappKey) == Wallet sendKey (walletToDappKey)
-    expect(dappState.recvKey).toBe(walletState.sendKey);
+    expect(dappState.recvKey).toBe(walletState.sendKey)
 
     // sendKey != recvKey (directional)
-    expect(dappState.sendKey).not.toBe(dappState.recvKey);
-  });
+    expect(dappState.sendKey).not.toBe(dappState.recvKey)
+  })
 
   it('restored session can still communicate', async () => {
-    const dappTransport = new MockTransport();
-    const walletTransport = new MockTransport();
-    const _relay = new MockRelay(dappTransport, walletTransport);
+    const dappTransport = new MockTransport()
+    const walletTransport = new MockTransport()
+    const _relay = new MockRelay(dappTransport, walletTransport)
 
-    const dappSession = new DAppSession({ transport: dappTransport, meta: { name: 'Restore dApp', description: 'Test', url: 'https://test.com', icon: 'https://test.com/icon.png' } });
+    const dappSession = new DAppSession({
+      transport: dappTransport,
+      meta: {
+        name: 'Restore dApp',
+        description: 'Test',
+        url: 'https://test.com',
+        icon: 'https://test.com/icon.png',
+      },
+    })
     const walletSession = new WalletSession({
       transport: walletTransport,
       capabilities: { methods: ['wallet_getAccounts'], events: [], chains: ['eip155:1'] },
-      meta: { name: 'Restore Wallet', description: 'Test', url: 'https://test.com', icon: 'https://test.com/icon.png' },
-    });
+      meta: {
+        name: 'Restore Wallet',
+        description: 'Test',
+        url: 'https://test.com',
+        icon: 'https://test.com/icon.png',
+      },
+    })
 
-    const uri = await dappSession.createPairing();
-    await walletSession.joinFromUri(uri);
-    await wait();
-    await wait();
+    const uri = await dappSession.createPairing()
+    await walletSession.joinFromUri(uri)
+    await wait()
+    await wait()
 
     // Exchange one message to advance sequence counters
-    walletSession.on('request', ({ id }) => walletSession.approve(id, 'first'));
-    const r1 = await dappSession.request('wallet_getAccounts');
-    expect(r1).toBe('first');
+    walletSession.on('request', ({ id }) => walletSession.approve(id, 'first'))
+    const r1 = await dappSession.request('wallet_getAccounts')
+    expect(r1).toBe('first')
 
     // Serialize
-    const dappJson = dappSession.serialize();
-    const walletJson = walletSession.serialize();
+    const dappJson = dappSession.serialize()
+    const walletJson = walletSession.serialize()
 
     // Restore dApp session to a new transport that is linked to the wallet transport
-    const newDappTransport = new MockTransport();
-    const newWalletTransport = new MockTransport();
-    newDappTransport.peer = newWalletTransport;
-    newWalletTransport.peer = newDappTransport;
-
-    const restoredDapp = new DAppSession({ transport: newDappTransport, meta: { name: 'Restore dApp', description: 'Test', url: 'https://test.com', icon: 'https://test.com/icon.png' } });
-    expect(restoredDapp.restore(dappJson)).toBe(true);
-    (restoredDapp as any).phase = 'connected';
+    const newDappTransport = new MockTransport()
+    const newWalletTransport = new MockTransport()
+    newDappTransport.peer = newWalletTransport
+    newWalletTransport.peer = newDappTransport
+
+    const restoredDapp = new DAppSession({
+      transport: newDappTransport,
+      meta: {
+        name: 'Restore dApp',
+        description: 'Test',
+        url: 'https://test.com',
+        icon: 'https://test.com/icon.png',
+      },
+    })
+    expect(restoredDapp.restore(dappJson)).toBe(true)
+    ;(restoredDapp as any).phase = 'connected'
 
     const restoredWallet = new WalletSession({
       transport: newWalletTransport,
       capabilities: { methods: ['wallet_getAccounts'], events: [], chains: ['eip155:1'] },
-      meta: { name: 'Restore Wallet', description: 'Test', url: 'https://test.com', icon: 'https://test.com/icon.png' },
-    });
-    expect(restoredWallet.restore(walletJson)).toBe(true);
-    (restoredWallet as any).phase = 'connected';
+      meta: {
+        name: 'Restore Wallet',
+        description: 'Test',
+        url: 'https://test.com',
+        icon: 'https://test.com/icon.png',
+      },
+    })
+    expect(restoredWallet.restore(walletJson)).toBe(true)
+    ;(restoredWallet as any).phase = 'connected'
 
     // Set up request handler on restored wallet
-    restoredWallet.on('request', ({ id }) => restoredWallet.approve(id, 'restored'));
+    restoredWallet.on('request', ({ id }) => restoredWallet.approve(id, 'restored'))
 
     // Restored dApp sends request through linked transports
-    const r2 = await restoredDapp.request('wallet_getAccounts');
-    expect(r2).toBe('restored');
-  });
-});
+    const r2 = await restoredDapp.request('wallet_getAccounts')
+    expect(r2).toBe('restored')
+  })
+})