walletpair-sdk 1.0.2 → 1.0.5

package/src/evm/eip1193.test.ts

@@ -1,71 +1,91 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { WalletPairProvider } from './eip1193.js';
-import { DAppSession } from '../dapp-session.js';
-import { makeJoinBody, MockTransport } from '../test-helpers.js';
+import { describe, expect, it, vi } from 'vitest'
+import type { AadHeader } from '../crypto.js'
 import {
-  generateX25519KeyPair,
+  b64urlDecode,
   computeSharedSecret,
   deriveSessionKey,
+  generateX25519KeyPair,
   sealPayload,
-  b64urlDecode,
-} from '../crypto.js';
-import type { AadHeader } from '../crypto.js';
-import type { ProtocolMessage } from '../types.js';
+} from '../crypto.js'
+import { DAppSession } from '../dapp-session.js'
+import { MockTransport, makeJoinBody } from '../test-helpers.js'
+import type { ProtocolMessage } from '../types.js'
+import { WalletPairProvider } from './eip1193.js'
 
 function flushMicrotasks(): Promise<void> {
-  return new Promise((r) => setTimeout(r, 10));
+  return new Promise((r) => setTimeout(r, 10))
 }
 
 describe('WalletPairProvider', () => {
-  let transport: MockTransport;
-  let session: DAppSession;
-  let provider: WalletPairProvider;
-  let walletKp: ReturnType<typeof generateX25519KeyPair>;
-  let sessionKey: Uint8Array;
+  let transport: MockTransport
+  let session: DAppSession
+  let provider: WalletPairProvider
+  let walletKp: ReturnType<typeof generateX25519KeyPair>
+  let sessionKey: Uint8Array
 
   async function setupConnectedSession(chainId = 1) {
-    walletSendSeq = 0;
-    transport = new MockTransport();
-    session = new DAppSession({ transport, meta: { name: 'Test', description: 'Test dApp', url: 'https://test.com', icon: 'https://test.com/icon.png' } });
-    provider = new WalletPairProvider({ session, chainId });
-
-    await session.createPairing();
-    walletKp = generateX25519KeyPair();
+    walletSendSeq = 0
+    transport = new MockTransport()
+    session = new DAppSession({
+      transport,
+      meta: {
+        name: 'Test',
+        description: 'Test dApp',
+        url: 'https://test.com',
+        icon: 'https://test.com/icon.png',
+      },
+    })
+    provider = new WalletPairProvider({ session, chainId })
+
+    await session.createPairing()
+    walletKp = generateX25519KeyPair()
 
     // Join
     transport.receive({
-      v: 1, t: 'join', ch: session.channelId,
-      ts: Date.now(), from: walletKp.publicKeyB64,
-      body: makeJoinBody(session.channelId, transport.sent[0]!.from!, walletKp),
-    } as ProtocolMessage);
+      v: 1,
+      t: 'join',
+      ch: session.channelId,
+      ts: Date.now(),
+      from: walletKp.publicKeyB64,
+      body: makeJoinBody(session.channelId, transport.sent[0]?.from!, walletKp),
+    } as ProtocolMessage)
 
     // Responses/events from the manual wallet use the wallet->dApp key.
-    const dappPub = b64urlDecode(transport.sent[0]!.from!);
-    const shared = computeSharedSecret(walletKp.privateKey, dappPub);
-    deriveSessionKey(shared, session.channelId);
-    sessionKey = (session as any).recvKey;
+    const dappPub = b64urlDecode(transport.sent[0]?.from!)
+    const shared = computeSharedSecret(walletKp.privateKey, dappPub)
+    deriveSessionKey(shared, session.channelId)
+    sessionKey = (session as any).recvKey
 
     // Connect
     transport.receive({
-      v: 1, t: 'ready', ch: session.channelId,
-      ts: Date.now(), from: '_adapter',
+      v: 1,
+      t: 'ready',
+      ch: session.channelId,
+      ts: Date.now(),
+      from: '_adapter',
       body: { state: 'connected', reconnect: false, remote: walletKp.publicKeyB64 },
-    } as ProtocolMessage);
+    } as ProtocolMessage)
   }
 
-  let walletSendSeq = 0;
+  let walletSendSeq = 0
 
   function respondToLatestReq(result: unknown, ok = true) {
-    const reqMsg = [...transport.sent].reverse().find(m => m.t === 'req') as any;
-    if (!reqMsg) throw new Error('No req found');
-    const reqId = reqMsg.body.id;
-    const hdr: AadHeader = { type: 'res', from: walletKp.publicKeyB64, id: reqId };
-    const sealedData = ok ? { _ok: true, _result: result } : { _ok: false, ...result as object };
+    const reqMsg = [...transport.sent].reverse().find((m) => m.t === 'req') as any
+    if (!reqMsg) throw new Error('No req found')
+    const reqId = reqMsg.body.id
+    const hdr: AadHeader = { type: 'res', from: walletKp.publicKeyB64, id: reqId }
+    const sealedData = ok ? { _ok: true, _result: result } : { _ok: false, ...(result as object) }
     transport.receive({
-      v: 1, t: 'res', ch: session.channelId,
-      ts: Date.now(), from: walletKp.publicKeyB64,
-      body: { id: reqId, sealed: sealPayload(sessionKey, session.channelId, walletSendSeq++, sealedData, hdr) },
-    } as ProtocolMessage);
+      v: 1,
+      t: 'res',
+      ch: session.channelId,
+      ts: Date.now(),
+      from: walletKp.publicKeyB64,
+      body: {
+        id: reqId,
+        sealed: sealPayload(sessionKey, session.channelId, walletSendSeq++, sealedData, hdr),
+      },
+    } as ProtocolMessage)
   }
 
   // -----------------------------------------------------------------------
@@ -74,25 +94,25 @@ describe('WalletPairProvider', () => {
 
   describe('eth_chainId', () => {
     it('returns chain ID as hex (default mainnet)', async () => {
-      await setupConnectedSession();
-      const result = await provider.request({ method: 'eth_chainId' });
-      expect(result).toBe('0x1');
-    });
+      await setupConnectedSession()
+      const result = await provider.request({ method: 'eth_chainId' })
+      expect(result).toBe('0x1')
+    })
 
     it('returns custom chain ID', async () => {
-      await setupConnectedSession(137);
-      const result = await provider.request({ method: 'eth_chainId' });
-      expect(result).toBe('0x89');
-    });
-  });
+      await setupConnectedSession(137)
+      const result = await provider.request({ method: 'eth_chainId' })
+      expect(result).toBe('0x89')
+    })
+  })
 
   describe('net_version', () => {
     it('returns chain ID as decimal string', async () => {
-      await setupConnectedSession();
-      const result = await provider.request({ method: 'net_version' });
-      expect(result).toBe('1');
-    });
-  });
+      await setupConnectedSession()
+      const result = await provider.request({ method: 'net_version' })
+      expect(result).toBe('1')
+    })
+  })
 
   // -----------------------------------------------------------------------
   // eth_requestAccounts / eth_accounts
@@ -100,47 +120,47 @@ describe('WalletPairProvider', () => {
 
   describe('eth_requestAccounts', () => {
     it('maps to wallet_getAccounts and returns result', async () => {
-      await setupConnectedSession();
+      await setupConnectedSession()
 
-      const promise = provider.request({ method: 'eth_requestAccounts' });
-      await flushMicrotasks();
+      const promise = provider.request({ method: 'eth_requestAccounts' })
+      await flushMicrotasks()
 
       // Verify it sent wallet_getAccounts
-      const reqMsg = transport.sent.find(m => m.t === 'req') as any;
-      expect(reqMsg.body.sealed).toBeTruthy(); // method inside sealed
+      const reqMsg = transport.sent.find((m) => m.t === 'req') as any
+      expect(reqMsg.body.sealed).toBeTruthy() // method inside sealed
 
-      respondToLatestReq(['0xabc123']);
-      const result = await promise;
-      expect(result).toEqual(['0xabc123']);
-    });
+      respondToLatestReq(['0xabc123'])
+      const result = await promise
+      expect(result).toEqual(['0xabc123'])
+    })
 
     it('caches accounts after request', async () => {
-      await setupConnectedSession();
+      await setupConnectedSession()
 
-      const promise = provider.request({ method: 'eth_requestAccounts' });
-      await flushMicrotasks();
-      respondToLatestReq(['0xabc123']);
-      await promise;
+      const promise = provider.request({ method: 'eth_requestAccounts' })
+      await flushMicrotasks()
+      respondToLatestReq(['0xabc123'])
+      await promise
 
-      expect(provider.getAccounts()).toEqual(['0xabc123']);
-    });
-  });
+      expect(provider.getAccounts()).toEqual(['0xabc123'])
+    })
+  })
 
   describe('eth_accounts', () => {
     it('maps to wallet_getAccounts', async () => {
-      await setupConnectedSession();
+      await setupConnectedSession()
 
-      const promise = provider.request({ method: 'eth_accounts' });
-      await flushMicrotasks();
+      const promise = provider.request({ method: 'eth_accounts' })
+      await flushMicrotasks()
 
-      const reqMsg = transport.sent.find(m => m.t === 'req') as any;
-      expect(reqMsg.body.sealed).toBeTruthy(); // method inside sealed
+      const reqMsg = transport.sent.find((m) => m.t === 'req') as any
+      expect(reqMsg.body.sealed).toBeTruthy() // method inside sealed
 
-      respondToLatestReq(['0x456']);
-      const result = await promise;
-      expect(result).toEqual(['0x456']);
-    });
-  });
+      respondToLatestReq(['0x456'])
+      const result = await promise
+      expect(result).toEqual(['0x456'])
+    })
+  })
 
   // -----------------------------------------------------------------------
   // personal_sign
@@ -148,41 +168,41 @@ describe('WalletPairProvider', () => {
 
   describe('personal_sign', () => {
     it('maps hex data to wallet_signMessage with decoded text', async () => {
-      await setupConnectedSession();
+      await setupConnectedSession()
 
       // 0x48656c6c6f is "Hello" in hex
       const promise = provider.request({
         method: 'personal_sign',
         params: ['0x48656c6c6f', '0xabc'],
-      });
-      await flushMicrotasks();
+      })
+      await flushMicrotasks()
 
-      const reqMsg = transport.sent.find(m => m.t === 'req') as any;
-      expect(reqMsg.body.sealed).toBeTruthy(); // method inside sealed
+      const reqMsg = transport.sent.find((m) => m.t === 'req') as any
+      expect(reqMsg.body.sealed).toBeTruthy() // method inside sealed
 
       // Wallet responds with { signature }, mapResponse unwraps to just the string
-      respondToLatestReq({ signature: '0xsig...' });
-      const result = await promise;
-      expect(result).toBe('0xsig...');
-    });
+      respondToLatestReq({ signature: '0xsig...' })
+      const result = await promise
+      expect(result).toBe('0xsig...')
+    })
 
     it('maps plain text to wallet_signMessage', async () => {
-      await setupConnectedSession();
+      await setupConnectedSession()
 
       const promise = provider.request({
         method: 'personal_sign',
         params: ['Hello, WalletPair!', '0xabc'],
-      });
-      await flushMicrotasks();
+      })
+      await flushMicrotasks()
 
-      const reqMsg = transport.sent.find(m => m.t === 'req') as any;
-      expect(reqMsg.body.sealed).toBeTruthy(); // method inside sealed
+      const reqMsg = transport.sent.find((m) => m.t === 'req') as any
+      expect(reqMsg.body.sealed).toBeTruthy() // method inside sealed
 
-      respondToLatestReq({ signature: '0xsig...' });
-      const result = await promise;
-      expect(result).toBe('0xsig...');
-    });
-  });
+      respondToLatestReq({ signature: '0xsig...' })
+      const result = await promise
+      expect(result).toBe('0xsig...')
+    })
+  })
 
   // -----------------------------------------------------------------------
   // eth_sendTransaction
@@ -190,24 +210,24 @@ describe('WalletPairProvider', () => {
 
   describe('eth_sendTransaction', () => {
     it('maps to wallet_sendTransaction', async () => {
-      await setupConnectedSession();
+      await setupConnectedSession()
 
-      const tx = { to: '0x123', value: '0x0', data: '0x' };
+      const tx = { to: '0x123', value: '0x0', data: '0x', type: '0x2', chainId: '0x1' }
       const promise = provider.request({
         method: 'eth_sendTransaction',
         params: [tx],
-      });
-      await flushMicrotasks();
+      })
+      await flushMicrotasks()
 
-      const reqMsg = transport.sent.find(m => m.t === 'req') as any;
-      expect(reqMsg.body.sealed).toBeTruthy(); // method inside sealed
+      const reqMsg = transport.sent.find((m) => m.t === 'req') as any
+      expect(reqMsg.body.sealed).toBeTruthy() // method inside sealed
 
       // mapResponse unwraps { txHash } to just the hash string
-      respondToLatestReq({ txHash: '0xtx...' });
-      const result = await promise;
-      expect(result).toBe('0xtx...');
-    });
-  });
+      respondToLatestReq({ txHash: '0xtx...' })
+      const result = await promise
+      expect(result).toBe('0xtx...')
+    })
+  })
 
   // -----------------------------------------------------------------------
   // wallet_switchEthereumChain
@@ -215,21 +235,21 @@ describe('WalletPairProvider', () => {
 
   describe('wallet_switchEthereumChain', () => {
     it('maps to wallet_switchChain', async () => {
-      await setupConnectedSession();
+      await setupConnectedSession()
 
       const promise = provider.request({
         method: 'wallet_switchEthereumChain',
         params: [{ chainId: '0x89' }],
-      });
-      await flushMicrotasks();
+      })
+      await flushMicrotasks()
 
-      const reqMsg = transport.sent.find(m => m.t === 'req') as any;
-      expect(reqMsg.body.sealed).toBeTruthy(); // method inside sealed
+      const reqMsg = transport.sent.find((m) => m.t === 'req') as any
+      expect(reqMsg.body.sealed).toBeTruthy() // method inside sealed
 
-      respondToLatestReq({ success: true });
-      await promise;
-    });
-  });
+      respondToLatestReq({ success: true })
+      await promise
+    })
+  })
 
   // -----------------------------------------------------------------------
   // Events
@@ -237,79 +257,127 @@ describe('WalletPairProvider', () => {
 
   describe('EIP-1193 events', () => {
     it('emits connect when session connects', async () => {
-      await setupConnectedSession();
+      await setupConnectedSession()
       // Provider constructor registered the listener, and session is already connected
-      expect(provider.isConnected()).toBe(true);
-    });
+      expect(provider.isConnected()).toBe(true)
+    })
 
     it('emits disconnect when session closes', async () => {
-      await setupConnectedSession();
-      const handler = vi.fn();
-      provider.on('disconnect', handler);
+      await setupConnectedSession()
+      const handler = vi.fn()
+      provider.on('disconnect', handler)
 
-      session.close();
-      expect(handler).toHaveBeenCalledWith({ code: 4900, message: 'Disconnected' });
-      expect(provider.isConnected()).toBe(false);
-    });
+      session.close()
+      expect(handler).toHaveBeenCalledWith({ code: 4900, message: 'Disconnected' })
+      expect(provider.isConnected()).toBe(false)
+    })
 
     it('emits accountsChanged from wallet event', async () => {
-      await setupConnectedSession();
-      const handler = vi.fn();
-      provider.on('accountsChanged', handler);
+      await setupConnectedSession()
+      const handler = vi.fn()
+      provider.on('accountsChanged', handler)
 
       transport.receive({
-        v: 1, t: 'evt', ch: session.channelId,
-        ts: Date.now(), from: walletKp.publicKeyB64,
-        body: { id: 'evt-1', sealed: sealPayload(sessionKey, session.channelId, 0, { _event: 'accountsChanged', accounts: ['0xnew'] }, { type: 'evt', from: walletKp.publicKeyB64, id: 'evt-1' }) },
-      } as ProtocolMessage);
-
-      expect(handler).toHaveBeenCalledWith(['0xnew']);
-      expect(provider.getAccounts()).toEqual(['0xnew']);
-    });
+        v: 1,
+        t: 'evt',
+        ch: session.channelId,
+        ts: Date.now(),
+        from: walletKp.publicKeyB64,
+        body: {
+          id: 'evt-1',
+          sealed: sealPayload(
+            sessionKey,
+            session.channelId,
+            0,
+            { _event: 'accountsChanged', accounts: ['0xnew'] },
+            { type: 'evt', from: walletKp.publicKeyB64, id: 'evt-1' },
+          ),
+        },
+      } as ProtocolMessage)
+
+      expect(handler).toHaveBeenCalledWith(['0xnew'])
+      expect(provider.getAccounts()).toEqual(['0xnew'])
+    })
 
     it('emits chainChanged from wallet event (CAIP-2 format)', async () => {
-      await setupConnectedSession();
-      const handler = vi.fn();
-      provider.on('chainChanged', handler);
+      await setupConnectedSession()
+      const handler = vi.fn()
+      provider.on('chainChanged', handler)
 
       transport.receive({
-        v: 1, t: 'evt', ch: session.channelId,
-        ts: Date.now(), from: walletKp.publicKeyB64,
-        body: { id: 'evt-2', sealed: sealPayload(sessionKey, session.channelId, 0, { _event: 'chainChanged', chainId: 'eip155:137' }, { type: 'evt', from: walletKp.publicKeyB64, id: 'evt-2' }) },
-      } as ProtocolMessage);
-
-      expect(handler).toHaveBeenCalledWith('0x89');
-    });
+        v: 1,
+        t: 'evt',
+        ch: session.channelId,
+        ts: Date.now(),
+        from: walletKp.publicKeyB64,
+        body: {
+          id: 'evt-2',
+          sealed: sealPayload(
+            sessionKey,
+            session.channelId,
+            0,
+            { _event: 'chainChanged', chainId: 'eip155:137' },
+            { type: 'evt', from: walletKp.publicKeyB64, id: 'evt-2' },
+          ),
+        },
+      } as ProtocolMessage)
+
+      expect(handler).toHaveBeenCalledWith('0x89')
+    })
 
     it('emits chainChanged from wallet event (hex format)', async () => {
-      await setupConnectedSession();
-      const handler = vi.fn();
-      provider.on('chainChanged', handler);
+      await setupConnectedSession()
+      const handler = vi.fn()
+      provider.on('chainChanged', handler)
 
       transport.receive({
-        v: 1, t: 'evt', ch: session.channelId,
-        ts: Date.now(), from: walletKp.publicKeyB64,
-        body: { id: 'evt-3', sealed: sealPayload(sessionKey, session.channelId, 0, { _event: 'chainChanged', chainId: '0x89' }, { type: 'evt', from: walletKp.publicKeyB64, id: 'evt-3' }) },
-      } as ProtocolMessage);
-
-      expect(handler).toHaveBeenCalledWith('0x89');
-    });
+        v: 1,
+        t: 'evt',
+        ch: session.channelId,
+        ts: Date.now(),
+        from: walletKp.publicKeyB64,
+        body: {
+          id: 'evt-3',
+          sealed: sealPayload(
+            sessionKey,
+            session.channelId,
+            0,
+            { _event: 'chainChanged', chainId: '0x89' },
+            { type: 'evt', from: walletKp.publicKeyB64, id: 'evt-3' },
+          ),
+        },
+      } as ProtocolMessage)
+
+      expect(handler).toHaveBeenCalledWith('0x89')
+    })
 
     it('removeListener stops event delivery', async () => {
-      await setupConnectedSession();
-      const handler = vi.fn();
-      provider.on('accountsChanged', handler);
-      provider.removeListener('accountsChanged', handler);
+      await setupConnectedSession()
+      const handler = vi.fn()
+      provider.on('accountsChanged', handler)
+      provider.removeListener('accountsChanged', handler)
 
       transport.receive({
-        v: 1, t: 'evt', ch: session.channelId,
-        ts: Date.now(), from: walletKp.publicKeyB64,
-        body: { id: 'evt-4', sealed: sealPayload(sessionKey, session.channelId, 0, { _event: 'accountsChanged', accounts: ['0x1'] }, { type: 'evt', from: walletKp.publicKeyB64, id: 'evt-4' }) },
-      } as ProtocolMessage);
-
-      expect(handler).not.toHaveBeenCalled();
-    });
-  });
+        v: 1,
+        t: 'evt',
+        ch: session.channelId,
+        ts: Date.now(),
+        from: walletKp.publicKeyB64,
+        body: {
+          id: 'evt-4',
+          sealed: sealPayload(
+            sessionKey,
+            session.channelId,
+            0,
+            { _event: 'accountsChanged', accounts: ['0x1'] },
+            { type: 'evt', from: walletKp.publicKeyB64, id: 'evt-4' },
+          ),
+        },
+      } as ProtocolMessage)
+
+      expect(handler).not.toHaveBeenCalled()
+    })
+  })
 
   // -----------------------------------------------------------------------
   // Helper methods
@@ -317,15 +385,15 @@ describe('WalletPairProvider', () => {
 
   describe('helper methods', () => {
     it('getChainId returns hex string', async () => {
-      await setupConnectedSession(42161);
-      expect(provider.getChainId()).toBe('0xa4b1');
-    });
+      await setupConnectedSession(42161)
+      expect(provider.getChainId()).toBe('0xa4b1')
+    })
 
     it('getSession returns the underlying session', async () => {
-      await setupConnectedSession();
-      expect(provider.getSession()).toBe(session);
-    });
-  });
+      await setupConnectedSession()
+      expect(provider.getSession()).toBe(session)
+    })
+  })
 
   // -----------------------------------------------------------------------
   // Error handling
@@ -333,33 +401,43 @@ describe('WalletPairProvider', () => {
 
   describe('error handling', () => {
     it('rejects on wallet error response', async () => {
-      await setupConnectedSession();
+      await setupConnectedSession()
 
-      const promise = provider.request({ method: 'eth_requestAccounts' });
-      await flushMicrotasks();
+      const promise = provider.request({ method: 'eth_requestAccounts' })
+      await flushMicrotasks()
 
-      respondToLatestReq({ code: 'user_rejected', message: 'Denied' }, false);
-      await expect(promise).rejects.toThrow('Denied');
-    });
-  });
+      respondToLatestReq({ code: 'user_rejected', message: 'Denied' }, false)
+      await expect(promise).rejects.toThrow('Denied')
+    })
+  })
 
   // -----------------------------------------------------------------------
   // Passthrough methods
   // -----------------------------------------------------------------------
 
   describe('unknown methods', () => {
-    it('passes unknown methods through to wallet', async () => {
-      await setupConnectedSession();
-
-      const promise = provider.request({ method: 'eth_getBalance', params: ['0x123', 'latest'] });
-      await flushMicrotasks();
-
-      const reqMsg = transport.sent.find(m => m.t === 'req') as any;
-      expect(reqMsg.body.sealed).toBeTruthy(); // method inside sealed
-
-      respondToLatestReq('0x1234');
-      const result = await promise;
-      expect(result).toBe('0x1234');
-    });
-  });
-});
+    it('routes read-only methods to rpcProvider when available', async () => {
+      await setupConnectedSession()
+      const rpcProvider = { request: vi.fn().mockResolvedValue('0x1234') }
+      ;(provider as any).rpcProvider = rpcProvider
+
+      const result = await provider.request({
+        method: 'eth_getBalance',
+        params: ['0x123', 'latest'],
+      })
+      expect(rpcProvider.request).toHaveBeenCalledWith({
+        method: 'eth_getBalance',
+        params: ['0x123', 'latest'],
+      })
+      expect(result).toBe('0x1234')
+    })
+
+    it('throws for read-only methods without rpcProvider', async () => {
+      await setupConnectedSession()
+
+      await expect(
+        provider.request({ method: 'eth_getBalance', params: ['0x123', 'latest'] }),
+      ).rejects.toThrow('Unsupported method: eth_getBalance')
+    })
+  })
+})