walletpair-sdk 1.0.0

package/src/emitter.test.ts

@@ -0,0 +1,169 @@
+import { describe, it, expect, vi } from 'vitest';
+import { Emitter } from './emitter.js';
+
+interface TestEvents {
+  [key: string]: unknown;
+  message: string;
+  count: number;
+  complex: { name: string; value: number };
+}
+
+describe('Emitter', () => {
+  it('emits events to registered handlers', () => {
+    const emitter = new Emitter<TestEvents>();
+    const handler = vi.fn();
+    emitter.on('message', handler);
+    emitter.emit('message', 'hello');
+    expect(handler).toHaveBeenCalledWith('hello');
+    expect(handler).toHaveBeenCalledTimes(1);
+  });
+
+  it('supports multiple handlers for the same event', () => {
+    const emitter = new Emitter<TestEvents>();
+    const h1 = vi.fn();
+    const h2 = vi.fn();
+    emitter.on('message', h1);
+    emitter.on('message', h2);
+    emitter.emit('message', 'test');
+    expect(h1).toHaveBeenCalledWith('test');
+    expect(h2).toHaveBeenCalledWith('test');
+  });
+
+  it('supports multiple event types', () => {
+    const emitter = new Emitter<TestEvents>();
+    const msgHandler = vi.fn();
+    const countHandler = vi.fn();
+    emitter.on('message', msgHandler);
+    emitter.on('count', countHandler);
+
+    emitter.emit('message', 'hello');
+    emitter.emit('count', 42);
+
+    expect(msgHandler).toHaveBeenCalledWith('hello');
+    expect(countHandler).toHaveBeenCalledWith(42);
+    expect(msgHandler).toHaveBeenCalledTimes(1);
+    expect(countHandler).toHaveBeenCalledTimes(1);
+  });
+
+  it('on() returns an unsubscribe function', () => {
+    const emitter = new Emitter<TestEvents>();
+    const handler = vi.fn();
+    const off = emitter.on('message', handler);
+
+    emitter.emit('message', 'first');
+    expect(handler).toHaveBeenCalledTimes(1);
+
+    off();
+    emitter.emit('message', 'second');
+    expect(handler).toHaveBeenCalledTimes(1); // not called again
+  });
+
+  it('off() removes a specific handler', () => {
+    const emitter = new Emitter<TestEvents>();
+    const h1 = vi.fn();
+    const h2 = vi.fn();
+    emitter.on('message', h1);
+    emitter.on('message', h2);
+
+    emitter.off('message', h1);
+    emitter.emit('message', 'test');
+
+    expect(h1).not.toHaveBeenCalled();
+    expect(h2).toHaveBeenCalledWith('test');
+  });
+
+  it('off() without handler removes all handlers for that event', () => {
+    const emitter = new Emitter<TestEvents>();
+    const h1 = vi.fn();
+    const h2 = vi.fn();
+    emitter.on('message', h1);
+    emitter.on('message', h2);
+
+    emitter.off('message');
+    emitter.emit('message', 'test');
+
+    expect(h1).not.toHaveBeenCalled();
+    expect(h2).not.toHaveBeenCalled();
+  });
+
+  it('once() fires handler only once', () => {
+    const emitter = new Emitter<TestEvents>();
+    const handler = vi.fn();
+    emitter.once('message', handler);
+
+    emitter.emit('message', 'first');
+    emitter.emit('message', 'second');
+
+    expect(handler).toHaveBeenCalledTimes(1);
+    expect(handler).toHaveBeenCalledWith('first');
+  });
+
+  it('once() returns an unsubscribe function that works before emit', () => {
+    const emitter = new Emitter<TestEvents>();
+    const handler = vi.fn();
+    const off = emitter.once('message', handler);
+
+    off(); // cancel before any emission
+    emitter.emit('message', 'test');
+    expect(handler).not.toHaveBeenCalled();
+  });
+
+  it('removeAll() clears all events', () => {
+    const emitter = new Emitter<TestEvents>();
+    const h1 = vi.fn();
+    const h2 = vi.fn();
+    emitter.on('message', h1);
+    emitter.on('count', h2);
+
+    emitter.removeAll();
+    emitter.emit('message', 'test');
+    emitter.emit('count', 1);
+
+    expect(h1).not.toHaveBeenCalled();
+    expect(h2).not.toHaveBeenCalled();
+  });
+
+  it('emitting with no handlers does not throw', () => {
+    const emitter = new Emitter<TestEvents>();
+    expect(() => emitter.emit('message', 'test')).not.toThrow();
+  });
+
+  it('handles complex event data', () => {
+    const emitter = new Emitter<TestEvents>();
+    const handler = vi.fn();
+    emitter.on('complex', handler);
+
+    const data = { name: 'test', value: 99 };
+    emitter.emit('complex', data);
+    expect(handler).toHaveBeenCalledWith(data);
+  });
+
+  it('handler added during emit is not called in the same emit cycle', () => {
+    const emitter = new Emitter<TestEvents>();
+    const late = vi.fn();
+    emitter.on('message', () => {
+      emitter.on('message', late);
+    });
+    emitter.emit('message', 'trigger');
+    // The late handler was added during iteration, behavior depends on Set iteration
+    // but it should not cause errors
+  });
+
+  it('multiple on() calls return independent unsubscribe functions', () => {
+    const emitter = new Emitter<TestEvents>();
+    const handler = vi.fn();
+    const off1 = emitter.on('message', handler);
+    const off2 = emitter.on('count', handler);
+
+    off1();
+    emitter.emit('message', 'gone');
+    emitter.emit('count', 42);
+
+    expect(handler).toHaveBeenCalledTimes(1);
+    expect(handler).toHaveBeenCalledWith(42);
+
+    off2();
+    emitter.emit('count', 99);
+    expect(handler).toHaveBeenCalledTimes(1);
+  });
+});

package/src/emitter.ts

@@ -0,0 +1,45 @@
+/**
+ * Minimal typed event emitter — no external dependencies.
+ */
+
+type Handler<T> = (data: T) => void;
+
+// biome-ignore lint: index signature needed for generic emitter
+export class Emitter<Events extends { [key: string]: unknown }> {
+  private handlers = new Map<keyof Events, Set<Handler<any>>>();
+
+  on<K extends keyof Events>(event: K, handler: Handler<Events[K]>): () => void {
+    let set = this.handlers.get(event);
+    if (!set) {
+      set = new Set();
+      this.handlers.set(event, set);
+    }
+    set.add(handler);
+    return () => { set!.delete(handler); };
+  }
+
+  once<K extends keyof Events>(event: K, handler: Handler<Events[K]>): () => void {
+    const off = this.on(event, (data) => {
+      off();
+      handler(data);
+    });
+    return off;
+  }
+
+  emit<K extends keyof Events>(event: K, data: Events[K]): void {
+    const set = this.handlers.get(event);
+    if (set) for (const h of set) h(data);
+  }
+
+  off<K extends keyof Events>(event: K, handler?: Handler<Events[K]>): void {
+    if (handler) {
+      this.handlers.get(event)?.delete(handler);
+    } else {
+      this.handlers.delete(event);
+    }
+  }
+
+  removeAll(): void {
+    this.handlers.clear();
+  }
+}

package/src/evm/eip1193.test.ts

@@ -0,0 +1,365 @@
+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 {
+  generateX25519KeyPair,
+  computeSharedSecret,
+  deriveSessionKey,
+  sealPayload,
+  b64urlDecode,
+} from '../crypto.js';
+import type { AadHeader } from '../crypto.js';
+import type { ProtocolMessage } from '../types.js';
+
+function flushMicrotasks(): Promise<void> {
+  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;
+
+  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();
+
+    // 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);
+
+    // 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;
+
+    // Connect
+    transport.receive({
+      v: 1, t: 'ready', ch: session.channelId,
+      ts: Date.now(), from: '_adapter',
+      body: { state: 'connected', reconnect: false, remote: walletKp.publicKeyB64 },
+    } as ProtocolMessage);
+  }
+
+  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 };
+    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);
+  }
+
+  // -----------------------------------------------------------------------
+  // eth_chainId
+  // -----------------------------------------------------------------------
+
+  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');
+    });
+
+    it('returns custom chain ID', async () => {
+      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');
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // eth_requestAccounts / eth_accounts
+  // -----------------------------------------------------------------------
+
+  describe('eth_requestAccounts', () => {
+    it('maps to wallet_getAccounts and returns result', async () => {
+      await setupConnectedSession();
+
+      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
+
+      respondToLatestReq(['0xabc123']);
+      const result = await promise;
+      expect(result).toEqual(['0xabc123']);
+    });
+
+    it('caches accounts after request', async () => {
+      await setupConnectedSession();
+
+      const promise = provider.request({ method: 'eth_requestAccounts' });
+      await flushMicrotasks();
+      respondToLatestReq(['0xabc123']);
+      await promise;
+
+      expect(provider.getAccounts()).toEqual(['0xabc123']);
+    });
+  });
+
+  describe('eth_accounts', () => {
+    it('maps to wallet_getAccounts', async () => {
+      await setupConnectedSession();
+
+      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
+
+      respondToLatestReq(['0x456']);
+      const result = await promise;
+      expect(result).toEqual(['0x456']);
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // personal_sign
+  // -----------------------------------------------------------------------
+
+  describe('personal_sign', () => {
+    it('maps hex data to wallet_signMessage with decoded text', async () => {
+      await setupConnectedSession();
+
+      // 0x48656c6c6f is "Hello" in hex
+      const promise = provider.request({
+        method: 'personal_sign',
+        params: ['0x48656c6c6f', '0xabc'],
+      });
+      await flushMicrotasks();
+
+      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...');
+    });
+
+    it('maps plain text to wallet_signMessage', async () => {
+      await setupConnectedSession();
+
+      const promise = provider.request({
+        method: 'personal_sign',
+        params: ['Hello, WalletPair!', '0xabc'],
+      });
+      await flushMicrotasks();
+
+      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...');
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // eth_sendTransaction
+  // -----------------------------------------------------------------------
+
+  describe('eth_sendTransaction', () => {
+    it('maps to wallet_sendTransaction', async () => {
+      await setupConnectedSession();
+
+      const tx = { to: '0x123', value: '0x0', data: '0x' };
+      const promise = provider.request({
+        method: 'eth_sendTransaction',
+        params: [tx],
+      });
+      await flushMicrotasks();
+
+      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...');
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // wallet_switchEthereumChain
+  // -----------------------------------------------------------------------
+
+  describe('wallet_switchEthereumChain', () => {
+    it('maps to wallet_switchChain', async () => {
+      await setupConnectedSession();
+
+      const promise = provider.request({
+        method: 'wallet_switchEthereumChain',
+        params: [{ chainId: '0x89' }],
+      });
+      await flushMicrotasks();
+
+      const reqMsg = transport.sent.find(m => m.t === 'req') as any;
+      expect(reqMsg.body.sealed).toBeTruthy(); // method inside sealed
+
+      respondToLatestReq({ success: true });
+      await promise;
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // Events
+  // -----------------------------------------------------------------------
+
+  describe('EIP-1193 events', () => {
+    it('emits connect when session connects', async () => {
+      await setupConnectedSession();
+      // Provider constructor registered the listener, and session is already connected
+      expect(provider.isConnected()).toBe(true);
+    });
+
+    it('emits disconnect when session closes', async () => {
+      await setupConnectedSession();
+      const handler = vi.fn();
+      provider.on('disconnect', handler);
+
+      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);
+
+      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']);
+    });
+
+    it('emits chainChanged from wallet event (CAIP-2 format)', async () => {
+      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');
+    });
+
+    it('emits chainChanged from wallet event (hex format)', async () => {
+      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');
+    });
+
+    it('removeListener stops event delivery', async () => {
+      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();
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // Helper methods
+  // -----------------------------------------------------------------------
+
+  describe('helper methods', () => {
+    it('getChainId returns hex string', async () => {
+      await setupConnectedSession(42161);
+      expect(provider.getChainId()).toBe('0xa4b1');
+    });
+
+    it('getSession returns the underlying session', async () => {
+      await setupConnectedSession();
+      expect(provider.getSession()).toBe(session);
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // Error handling
+  // -----------------------------------------------------------------------
+
+  describe('error handling', () => {
+    it('rejects on wallet error response', async () => {
+      await setupConnectedSession();
+
+      const promise = provider.request({ method: 'eth_requestAccounts' });
+      await flushMicrotasks();
+
+      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');
+    });
+  });
+});