From 1a98a0a840c6db630438b8e9e1ae1043b5398852 Mon Sep 17 00:00:00 2001 From: highlander Date: Tue, 2 Sep 2025 18:26:21 -0500 Subject: [PATCH 01/18] working good --- CLAUDE.md | 174 ++++++ chrome-extension/build-injected.mjs | 36 ++ chrome-extension/package.json | 5 +- chrome-extension/public/injected.js | 621 +++++++++++----------- chrome-extension/src/injected/injected.ts | 450 ++++++++++++++++ chrome-extension/src/injected/types.ts | 88 +++ docs/INJECTION_ARCHITECTURE.md | 205 +++++++ docs/Notes.md | 434 +++++++++++++++ pages/content/src/index.ts | 332 +++++++++++- 9 files changed, 2022 insertions(+), 323 deletions(-) create mode 100644 CLAUDE.md create mode 100644 chrome-extension/build-injected.mjs create mode 100644 chrome-extension/src/injected/injected.ts create mode 100644 chrome-extension/src/injected/types.ts create mode 100644 docs/INJECTION_ARCHITECTURE.md create mode 100644 docs/Notes.md diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..ae49034 --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,174 @@ +# CLAUDE.md + +This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. + +## Repository Overview + +KeepKey Client is a browser extension for the KeepKey hardware wallet, built using React, TypeScript, and Vite with a Turborepo monorepo architecture. The extension supports Chrome and Firefox (Manifest V3). + +## Development Commands + +### Core Development +```bash +# Install dependencies (requires pnpm 9.9.0+, Node >=18.19.1) +pnpm install + +# Development mode with hot reload +pnpm dev # Chrome +pnpm dev:firefox # Firefox + +# Production build +pnpm build # Chrome +pnpm build:firefox # Firefox + +# Create distributable zip +pnpm zip # Chrome (creates extension.zip) +pnpm zip:firefox # Firefox +``` + +### Testing & Quality +```bash +# Run E2E tests (builds and zips first) +pnpm e2e # Chrome +pnpm e2e:firefox # Firefox + +# Type checking +pnpm type-check + +# Linting & formatting +pnpm lint # Run ESLint with fixes +pnpm lint:fix # Fix all linting issues +pnpm prettier # Format code with Prettier + +# Run specific E2E test +pnpm -F @extension/e2e e2e +``` + +### Clean & Reset +```bash +# Clean build artifacts +pnpm clean:bundle # Remove dist and dist-zip +pnpm clean:node_modules # Remove all node_modules +pnpm clean:turbo # Clear Turbo cache +pnpm clean # Full clean (all above) +pnpm clean:install # Clean + reinstall dependencies +``` + +## Architecture & Structure + +### Monorepo Layout +The project uses Turborepo with pnpm workspaces: + +- **`chrome-extension/`**: Core extension with background script and manifest configuration +- **`packages/`**: Shared packages used across the extension + - `dev-utils`: Development utilities and manifest parser + - `hmr`: Custom hot module reload plugin for Vite + - `i18n`: Internationalization with type safety + - `shared`: Shared hooks, components, and utilities + - `storage`: Chrome storage API helpers with TypeScript + - `ui`: Reusable UI components + - `vite-config`: Shared Vite configuration + - `zipper`: Build artifact packaging +- **`pages/`**: Extension pages and entry points + - `popup`: Main extension popup UI + - `side-panel`: Chrome side panel (not available in Firefox) + - `options`: Extension settings page + - `content`: Content script for page injection + - `content-ui`: Content script UI components + - `devtools`: Developer tools integration + +### Key Architecture Patterns + +**Background Service Worker**: Located at `chrome-extension/src/background/index.ts`, handles: +- KeepKey hardware wallet connection monitoring (polls `http://localhost:1646` every 5 seconds) +- Chain-specific request handlers (Bitcoin, Ethereum, Cosmos, etc.) +- State management and icon updates based on connection status +- RPC request routing and approval flows + +**Multi-Chain Support**: Each blockchain has a dedicated handler in `chrome-extension/src/background/chains/`: +- EVM chains (Ethereum, BSC, Avalanche, etc.) +- UTXO chains (Bitcoin, Litecoin, Dogecoin, etc.) +- Cosmos ecosystem (THORChain, Maya, Osmosis) +- Unique chains (Ripple) + +**Storage Architecture**: Uses Chrome storage API with TypeScript wrappers: +- `requestStorage`: Pending wallet requests +- `web3ProviderStorage`: Web3 provider configuration +- `exampleSidebarStorage`: UI state persistence + +**Message Passing**: The extension uses Chrome runtime messaging for: +- Background ↔ Popup communication +- Content script ↔ Background communication +- State change notifications (KEEPKEY_STATE_CHANGED events) + +### Build System + +**Vite Configuration**: +- Each package/page has its own `vite.config.mts` +- Shared config via `@extension/vite-config` +- IIFE format for background script and content scripts +- Source maps in dev, minification in production + +**Manifest Generation**: Dynamic manifest.js with: +- Conditional features (side panel only for Chrome) +- Localization support via `__MSG_*` placeholders +- All permissions required for hardware wallet interaction + +## Environment Variables + +Create `.env` from `.example.env` and define types in `vite-env.d.ts`: +```typescript +interface ImportMetaEnv { + // Add your env var types here +} +``` + +## Extension Loading + +### Chrome +1. Navigate to `chrome://extensions` +2. Enable "Developer mode" +3. Click "Load unpacked" +4. Select the `dist` folder + +### Firefox +1. Navigate to `about:debugging#/runtime/this-firefox` +2. Click "Load Temporary Add-on" +3. Select `manifest.json` from `dist` folder +Note: Firefox extensions are temporary and need reloading after browser restart + +## Working with Turborepo + +```bash +# Install dependency for root +pnpm i -w + +# Install for specific workspace +pnpm i -F @extension/popup + +# Run command in specific workspace +pnpm -F @extension/e2e e2e + +# Build specific packages +turbo build --filter=@extension/popup +``` + +## State Management + +The extension tracks KeepKey connection states: +- 0: Unknown +- 1: Disconnected +- 2: Connected +- 3: Busy +- 4: Errored +- 5: Paired (address available) + +Icon changes based on state (online/offline variants). + +## Critical Files & Entry Points + +- **Background Script**: `chrome-extension/src/background/index.ts` +- **Popup Entry**: `pages/popup/src/index.tsx` +- **Manifest Config**: `chrome-extension/manifest.js` +- **Chain Handlers**: `chrome-extension/src/background/chains/*.ts` +- **Storage Types**: `packages/storage/lib/types.ts` \ No newline at end of file diff --git a/chrome-extension/build-injected.mjs b/chrome-extension/build-injected.mjs new file mode 100644 index 0000000..ad238a3 --- /dev/null +++ b/chrome-extension/build-injected.mjs @@ -0,0 +1,36 @@ +#!/usr/bin/env node + +import * as esbuild from 'esbuild'; +import { resolve, dirname } from 'path'; +import { fileURLToPath } from 'url'; + +const __filename = fileURLToPath(import.meta.url); +const __dirname = dirname(__filename); + +const isDev = process.env.NODE_ENV === 'development'; + +async function build() { + try { + await esbuild.build({ + entryPoints: [resolve(__dirname, 'src/injected/injected.ts')], + bundle: true, + outfile: resolve(__dirname, 'public/injected.js'), + format: 'iife', + platform: 'browser', + target: ['chrome90', 'firefox90'], + minify: !isDev, + sourcemap: isDev ? 'inline' : false, + define: { + 'process.env.NODE_ENV': JSON.stringify(isDev ? 'development' : 'production'), + }, + logLevel: 'info', + }); + + console.log('✅ Injected script built successfully'); + } catch (error) { + console.error('❌ Build failed:', error); + process.exit(1); + } +} + +build(); \ No newline at end of file diff --git a/chrome-extension/package.json b/chrome-extension/package.json index d97f980..0dce69b 100644 --- a/chrome-extension/package.json +++ b/chrome-extension/package.json @@ -7,8 +7,9 @@ "clean:node_modules": "pnpx rimraf node_modules", "clean:turbo": "rimraf .turbo", "clean": "pnpm clean:turbo && pnpm clean:node_modules", - "build": "vite build", - "dev": "cross-env __DEV__=true vite build --mode development", + "build:injected": "node build-injected.mjs", + "build": "pnpm build:injected && vite build", + "dev": "cross-env __DEV__=true NODE_ENV=development pnpm build:injected && vite build --mode development", "test": "vitest run", "lint": "eslint ./ --ext .ts,.js,.tsx,.jsx", "lint:fix": "pnpm lint --fix", diff --git a/chrome-extension/public/injected.js b/chrome-extension/public/injected.js index 6935fcc..0289546 100644 --- a/chrome-extension/public/injected.js +++ b/chrome-extension/public/injected.js @@ -1,324 +1,349 @@ -(function () { - const TAG = ' | InjectedScript | '; - const VERSION = '1.0.17'; - console.log('**** KeepKey Injection script ****:', VERSION); - - // Prevent multiple injections - if (window.keepkeyInjected) { - //console.log(TAG, 'KeepKey is already injected.'); - return; - } - window.keepkeyInjected = true; - - const SITE_URL = window.location.href; - const SOURCE_INFO = { - siteUrl: SITE_URL, - scriptSource: 'KeepKey Extension', - version: VERSION, - injectedTime: new Date().toISOString(), - }; - console.log('SOURCE_INFO:', SOURCE_INFO); - - let messageId = 0; - const callbacks = {}; - const messageQueue = []; - - function processQueue(requestInfo, callback) { - for (let i = 0; i < messageQueue.length; i++) { - const queuedMessage = messageQueue[i]; - if (queuedMessage.id === requestInfo.id) { - callback(null, queuedMessage.result); - messageQueue.splice(i, 1); // Remove the processed message from the queue - return true; +'use strict'; +(() => { + // src/injected/injected.ts + (function () { + const TAG = ' | KeepKeyInjected | '; + const VERSION = '2.0.0'; + const MAX_RETRY_COUNT = 3; + const RETRY_DELAY = 100; + const CALLBACK_TIMEOUT = 3e4; + const MESSAGE_QUEUE_MAX = 100; + const kWindow = window; + const injectionState = { + isInjected: false, + version: VERSION, + injectedAt: Date.now(), + retryCount: 0, + }; + if (kWindow.keepkeyInjectionState) { + const existing = kWindow.keepkeyInjectionState; + console.warn(TAG, `Existing injection detected v${existing.version}, current v${VERSION}`); + if (existing.version >= VERSION) { + console.log(TAG, 'Skipping injection, newer or same version already present'); + return; } + console.log(TAG, 'Upgrading injection to newer version'); } - return false; - } - - function walletRequest(method, params = [], chain, callback) { - const tag = TAG + ' | walletRequest | '; - try { - const requestId = ++messageId; - const requestInfo = { - id: requestId, - method, - params, - chain, - siteUrl: SOURCE_INFO.siteUrl, - scriptSource: SOURCE_INFO.scriptSource, - version: SOURCE_INFO.version, - requestTime: new Date().toISOString(), - referrer: document.referrer, - href: window.location.href, - userAgent: navigator.userAgent, - platform: navigator.platform, - language: navigator.language, - }; - //console.log(tag, 'method:', method); - //console.log(tag, 'params:', params); - //console.log(tag, 'chain:', chain); - - callbacks[requestId] = { callback }; - - window.postMessage( - { + kWindow.keepkeyInjectionState = injectionState; + console.log(TAG, `Initializing KeepKey Injection v${VERSION}`); + const SOURCE_INFO = { + siteUrl: window.location.href, + scriptSource: 'KeepKey Extension', + version: VERSION, + injectedTime: /* @__PURE__ */ new Date().toISOString(), + origin: window.location.origin, + protocol: window.location.protocol, + }; + let messageId = 0; + const callbacks = /* @__PURE__ */ new Map(); + const messageQueue = []; + let isContentScriptReady = false; + const cleanupCallbacks = () => { + const now = Date.now(); + callbacks.forEach((callback, id) => { + if (now - callback.timestamp > CALLBACK_TIMEOUT) { + console.warn(TAG, `Callback timeout for request ${id} (${callback.method})`); + callback.callback(new Error('Request timeout')); + callbacks.delete(id); + } + }); + }; + setInterval(cleanupCallbacks, 5e3); + const addToQueue = message => { + if (messageQueue.length >= MESSAGE_QUEUE_MAX) { + console.warn(TAG, 'Message queue full, removing oldest message'); + messageQueue.shift(); + } + messageQueue.push(message); + }; + const processQueue = () => { + if (!isContentScriptReady) return; + while (messageQueue.length > 0) { + const message = messageQueue.shift(); + if (message) { + window.postMessage(message, window.location.origin); + } + } + }; + const verifyInjection = (retryCount = 0) => { + return new Promise(resolve => { + const verifyId = ++messageId; + const timeout = setTimeout(() => { + if (retryCount < MAX_RETRY_COUNT) { + console.log(TAG, `Verification attempt ${retryCount + 1} failed, retrying...`); + setTimeout( + () => { + verifyInjection(retryCount + 1).then(resolve); + }, + RETRY_DELAY * Math.pow(2, retryCount), + ); + } else { + console.error(TAG, 'Failed to verify injection after max retries'); + injectionState.lastError = 'Failed to verify injection'; + resolve(false); + } + }, 1e3); + const handleVerification = event => { + var _a, _b, _c; + if ( + event.source === window && + ((_a = event.data) == null ? void 0 : _a.source) === 'keepkey-content' && + ((_b = event.data) == null ? void 0 : _b.type) === 'INJECTION_CONFIRMED' && + ((_c = event.data) == null ? void 0 : _c.requestId) === verifyId + ) { + clearTimeout(timeout); + window.removeEventListener('message', handleVerification); + isContentScriptReady = true; + injectionState.isInjected = true; + console.log(TAG, 'Injection verified successfully'); + processQueue(); + resolve(true); + } + }; + window.addEventListener('message', handleVerification); + window.postMessage( + { + source: 'keepkey-injected', + type: 'INJECTION_VERIFY', + requestId: verifyId, + version: VERSION, + timestamp: Date.now(), + }, + window.location.origin, + ); + }); + }; + function walletRequest(method, params = [], chain, callback) { + const tag = TAG + ' | walletRequest | '; + if (!method || typeof method !== 'string') { + console.error(tag, 'Invalid method:', method); + callback(new Error('Invalid method')); + return; + } + if (!Array.isArray(params)) { + console.warn(tag, 'Params not an array, wrapping:', params); + params = [params]; + } + try { + const requestId = ++messageId; + const requestInfo = { + id: requestId, + method, + params, + chain, + siteUrl: SOURCE_INFO.siteUrl, + scriptSource: SOURCE_INFO.scriptSource, + version: SOURCE_INFO.version, + requestTime: /* @__PURE__ */ new Date().toISOString(), + referrer: document.referrer, + href: window.location.href, + userAgent: navigator.userAgent, + platform: navigator.platform, + language: navigator.language, + }; + callbacks.set(requestId, { + callback, + timestamp: Date.now(), + method, + }); + const message = { source: 'keepkey-injected', type: 'WALLET_REQUEST', requestId, requestInfo, - }, - '*', - ); - - // Recheck the queue for any pending matches - processQueue(requestInfo, callback); - } catch (error) { - console.error(tag, `Error in walletRequest:`, error); - callback(error); // Use callback to return the error - } - } - - // Listen for responses from the content script - window.addEventListener('message', event => { - const tag = TAG + ' | window.message | '; - if (event.source !== window) return; - if (event.data && event.data.source === 'keepkey-content' && event.data.type === 'WALLET_RESPONSE') { - const { requestId, result, error } = event.data; - const storedCallback = callbacks[requestId]; - if (storedCallback) { - if (error) { - storedCallback.callback(error); + timestamp: Date.now(), + }; + if (isContentScriptReady) { + window.postMessage(message, window.location.origin); } else { - storedCallback.callback(null, result); + console.log(tag, 'Content script not ready, queueing request'); + addToQueue(message); } - delete callbacks[requestId]; - } else { - console.warn(tag, 'No callback found for requestId:', requestId); + } catch (error) { + console.error(tag, 'Error in walletRequest:', error); + callback(error); } } - }); - - function sendRequestAsync(payload, param1, callback) { - const tag = TAG + ' | sendRequestAsync | '; - //console.log(tag, 'payload:', payload); - //console.log(tag, 'param1:', param1); - //console.log(tag, 'callback:', callback); - - let chain = payload.chain || 'ethereum'; - - if (typeof callback === 'function') { - walletRequest(payload.method, payload.params, chain, (error, result) => { - if (error) { - callback(error); + window.addEventListener('message', event => { + const tag = TAG + ' | message | '; + if (event.source !== window) return; + const data = event.data; + if (!data || typeof data !== 'object') return; + if (data.source === 'keepkey-content' && data.type === 'INJECTION_CONFIRMED') { + isContentScriptReady = true; + processQueue(); + return; + } + if (data.source === 'keepkey-content' && data.type === 'WALLET_RESPONSE' && data.requestId) { + const callback = callbacks.get(data.requestId); + if (callback) { + if (data.error) { + callback.callback(data.error); + } else { + callback.callback(null, data.result); + } + callbacks.delete(data.requestId); } else { - callback(null, { id: payload.id, jsonrpc: '2.0', result }); + console.warn(tag, 'No callback found for requestId:', data.requestId); } - }); - } else { - console.error(tag, 'Callback is not a function:', callback); - } - } - - function sendRequestSync(payload, param1) { - const tag = TAG + ' | sendRequestSync | '; - //console.log(tag, 'wallet.sendSync called with:', payload); - let params = payload.params || param1; - let method = payload.method || payload; - let chain = payload.chain || 'ethereum'; - //console.log(tag, 'selected payload:', payload); - //console.log(tag, 'selected params:', params); - //console.log(tag, 'selected chain:', chain); - - return { - id: payload.id, - jsonrpc: '2.0', - result: walletRequest(method, params, chain, () => {}), - }; - } - - function createWalletObject(chain) { - console.log('Creating wallet object for chain:', chain); - let wallet = { - network: 'mainnet', - isKeepKey: true, - isMetaMask: true, - isConnected: true, - request: ({ method, params }) => { - return new Promise((resolve, reject) => { - walletRequest(method, params, chain, (error, result) => { + } + }); + function createWalletObject(chain) { + console.log(TAG, 'Creating wallet object for chain:', chain); + const wallet = { + network: 'mainnet', + isKeepKey: true, + isMetaMask: true, + isConnected: isContentScriptReady, + request: ({ method, params = [] }) => { + return new Promise((resolve, reject) => { + walletRequest(method, params, chain, (error, result) => { + if (error) { + reject(error); + } else { + resolve(result); + } + }); + }); + }, + send: (payload, param1, callback) => { + if (!payload.chain) { + payload.chain = chain; + } + if (typeof callback === 'function') { + walletRequest(payload.method, payload.params || param1, chain, (error, result) => { + if (error) { + callback(error); + } else { + callback(null, { id: payload.id, jsonrpc: '2.0', result }); + } + }); + } else { + console.warn(TAG, 'Synchronous send is deprecated and may not work properly'); + return { id: payload.id, jsonrpc: '2.0', result: null }; + } + }, + sendAsync: (payload, param1, callback) => { + if (!payload.chain) { + payload.chain = chain; + } + const cb = callback || param1; + if (typeof cb !== 'function') { + console.error(TAG, 'sendAsync requires a callback function'); + return; + } + walletRequest(payload.method, payload.params || param1, chain, (error, result) => { if (error) { - reject(error); + cb(error); } else { - resolve(result); + cb(null, { id: payload.id, jsonrpc: '2.0', result }); } }); - }); - }, - send: (payload, param1, callback) => { - //console.log('send:', { payload, param1, callback }); - if (!payload.chain) { - payload.chain = chain; - } - return callback ? sendRequestAsync(payload, param1, callback) : sendRequestSync(payload, param1); - }, - sendAsync: (payload, param1, callback) => { - //console.log('sendAsync:', { payload, param1, callback }); - if (!payload.chain) { - payload.chain = chain; - } - return sendRequestAsync(payload, param1, callback); - }, - on: (event, handler) => { - //console.log('Adding event listener for:', event); - window.addEventListener(event, handler); - }, - removeListener: (event, handler) => { - //console.log('Removing event listener for:', event); - window.removeEventListener(event, handler); - }, - removeAllListeners: () => { - //console.log('Removing all event listeners'); - // Implement as needed - }, - }; - if (chain === 'ethereum') { - wallet.chainId = '0x1'; - wallet.networkVersion = '1'; - } - - return wallet; - } - - function announceProvider(ethereumProvider) { - const info = { - uuid: '350670db-19fa-4704-a166-e52e178b59d4', - name: 'KeepKey Client', - icon: 'https://pioneers.dev/coins/keepkey.png', - rdns: 'com.keepkey', - }; - - const announceEvent = new CustomEvent('eip6963:announceProvider', { - detail: { info, provider: ethereumProvider }, - }); - - console.log(TAG, 'Dispatching provider event with correct detail:', announceEvent); - window.dispatchEvent(announceEvent); - } - - function mountWallet() { - const tag = TAG + ' | window.wallet | '; - - // Create wallet objects for each chain - const ethereum = createWalletObject('ethereum'); - const xfi = { - binance: createWalletObject('binance'), - bitcoin: createWalletObject('bitcoin'), - bitcoincash: createWalletObject('bitcoincash'), - dogecoin: createWalletObject('dogecoin'), - dash: createWalletObject('dash'), - ethereum: ethereum, - keplr: createWalletObject('keplr'), - litecoin: createWalletObject('litecoin'), - thorchain: createWalletObject('thorchain'), - mayachain: createWalletObject('mayachain'), - // solana: createWalletObject('solana'), - }; - - const keepkey = { - binance: createWalletObject('binance'), - bitcoin: createWalletObject('bitcoin'), - bitcoincash: createWalletObject('bitcoincash'), - dogecoin: createWalletObject('dogecoin'), - dash: createWalletObject('dash'), - ethereum: ethereum, - osmosis: createWalletObject('osmosis'), - cosmos: createWalletObject('cosmos'), - litecoin: createWalletObject('litecoin'), - thorchain: createWalletObject('thorchain'), - mayachain: createWalletObject('mayachain'), - ripple: createWalletObject('ripple'), - // solana: createWalletObject('solana'), - }; - - const handler = { - get: function (target, prop, receiver) { - //console.log(tag, `Proxy get handler: ${prop}`); - return Reflect.get(target, prop, receiver); - }, - set: function (target, prop, value) { - //console.log(tag, `Proxy set handler: ${prop} = ${value}`); - return Reflect.set(target, prop, value); - }, - }; - - const proxyEthereum = new Proxy(ethereum, handler); - const proxyXfi = new Proxy(xfi, handler); - const proxyKeepKey = new Proxy(keepkey, handler); - - const userOverrideSetting = true; - if (userOverrideSetting) { - if (typeof window.ethereum === 'undefined') { - console.log('Mounting window.ethereum'); - try { - Object.defineProperty(window, 'ethereum', { - value: proxyEthereum, - writable: false, - configurable: false, - }); - } catch (e) { - console.error('Failed to mount window.ethereum'); - } + }, + on: (event, handler) => { + window.addEventListener(event, handler); + }, + removeListener: (event, handler) => { + window.removeEventListener(event, handler); + }, + removeAllListeners: () => { + console.warn(TAG, 'removeAllListeners not fully implemented'); + }, + }; + if (chain === 'ethereum') { + wallet.chainId = '0x1'; + wallet.networkVersion = '1'; } + return wallet; + } + function announceProvider(ethereumProvider) { + const info = { + uuid: '350670db-19fa-4704-a166-e52e178b59d4', + name: 'KeepKey Client', + icon: 'https://pioneers.dev/coins/keepkey.png', + rdns: 'com.keepkey', + }; + const announceEvent = new CustomEvent('eip6963:announceProvider', { + detail: Object.freeze({ info, provider: ethereumProvider }), + }); + console.log(TAG, 'Announcing EIP-6963 provider'); + window.dispatchEvent(announceEvent); } - - if (userOverrideSetting) { - if (typeof window.xfi === 'undefined') { + async function mountWallet() { + const tag = TAG + ' | mountWallet | '; + console.log(tag, 'Starting wallet mount process'); + const verified = await verifyInjection(); + if (!verified) { + console.error(tag, 'Failed to verify injection, wallet features may not work'); + injectionState.lastError = 'Injection not verified'; + } + const ethereum = createWalletObject('ethereum'); + const xfi = { + binance: createWalletObject('binance'), + bitcoin: createWalletObject('bitcoin'), + bitcoincash: createWalletObject('bitcoincash'), + dogecoin: createWalletObject('dogecoin'), + dash: createWalletObject('dash'), + ethereum, + keplr: createWalletObject('keplr'), + litecoin: createWalletObject('litecoin'), + thorchain: createWalletObject('thorchain'), + mayachain: createWalletObject('mayachain'), + }; + const keepkey = { + binance: createWalletObject('binance'), + bitcoin: createWalletObject('bitcoin'), + bitcoincash: createWalletObject('bitcoincash'), + dogecoin: createWalletObject('dogecoin'), + dash: createWalletObject('dash'), + ethereum, + osmosis: createWalletObject('osmosis'), + cosmos: createWalletObject('cosmos'), + litecoin: createWalletObject('litecoin'), + thorchain: createWalletObject('thorchain'), + mayachain: createWalletObject('mayachain'), + ripple: createWalletObject('ripple'), + }; + const mountProvider = (name, provider) => { + if (kWindow[name]) { + console.warn(tag, `${name} already exists, checking if override is allowed`); + } try { - Object.defineProperty(window, 'xfi', { - value: proxyXfi, + Object.defineProperty(kWindow, name, { + value: provider, writable: false, - configurable: false, + configurable: true, + // Allow reconfiguration for updates }); + console.log(tag, `Successfully mounted window.${name}`); } catch (e) { - console.error('Failed to mount xfi'); + console.error(tag, `Failed to mount window.${name}:`, e); + injectionState.lastError = `Failed to mount ${name}`; } - } + }; + mountProvider('ethereum', ethereum); + mountProvider('xfi', xfi); + mountProvider('keepkey', keepkey); + announceProvider(ethereum); + window.addEventListener('eip6963:requestProvider', () => { + console.log(tag, 'Re-announcing provider on request'); + announceProvider(ethereum); + }); + window.addEventListener('message', event => { + var _a, _b; + if (((_a = event.data) == null ? void 0 : _a.type) === 'CHAIN_CHANGED' && ethereum.emit) { + console.log(tag, 'Chain changed:', event.data); + ethereum.emit('chainChanged', (_b = event.data.provider) == null ? void 0 : _b.chainId); + } + }); + console.log(tag, 'Wallet mount complete'); } - - if (typeof window.keepkey === 'undefined') { - try { - Object.defineProperty(window, 'keepkey', { - value: proxyKeepKey, - writable: false, - configurable: false, - }); - } catch (e) { - console.error('Failed to mount keepkey'); - } + if (document.readyState === 'loading') { + document.addEventListener('DOMContentLoaded', mountWallet); + } else { + mountWallet(); } - - console.log(tag, 'window.ethereum and window.keepkey have been mounted'); - - announceProvider(proxyEthereum); - - window.addEventListener('message', event => { - const tag = TAG + ' | window.message | '; - if (event.data.type === 'CHAIN_CHANGED') { - console.log(tag, 'Received CHAIN_CHANGED', event); - window.ethereum.emit('chainChanged', event.provider.chainId); // Notify dApps - } - if (event.source !== window) return; - if (event.data.type === 'ANNOUNCE_REQUEST') { - console.log(tag, 'Received ANNOUNCE_REQUEST'); - announceProvider(proxyEthereum); - } - }); - } - - mountWallet(); - if (document.readyState === 'complete' || document.readyState === 'interactive') { - mountWallet(); - } else { - document.addEventListener('DOMContentLoaded', mountWallet); - } + console.log(TAG, 'Injection script loaded and initialized'); + })(); })(); +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/injected/injected.ts"],
  "sourcesContent": ["import type { \n  WalletRequestInfo, \n  WalletMessage, \n  ProviderInfo, \n  WalletCallback,\n  InjectionState,\n  ChainType,\n  WalletProvider,\n  KeepKeyWindow\n} from './types';\n\n(function () {\n  const TAG = ' | KeepKeyInjected | ';\n  const VERSION = '2.0.0';\n  const MAX_RETRY_COUNT = 3;\n  const RETRY_DELAY = 100; // ms\n  const CALLBACK_TIMEOUT = 30000; // 30 seconds\n  const MESSAGE_QUEUE_MAX = 100;\n\n  const kWindow = window as KeepKeyWindow;\n\n  // Enhanced injection state tracking\n  const injectionState: InjectionState = {\n    isInjected: false,\n    version: VERSION,\n    injectedAt: Date.now(),\n    retryCount: 0\n  };\n\n  // Check for existing injection with version comparison\n  if (kWindow.keepkeyInjectionState) {\n    const existing = kWindow.keepkeyInjectionState;\n    console.warn(TAG, `Existing injection detected v${existing.version}, current v${VERSION}`);\n    \n    // Only skip if same or newer version\n    if (existing.version >= VERSION) {\n      console.log(TAG, 'Skipping injection, newer or same version already present');\n      return;\n    }\n    console.log(TAG, 'Upgrading injection to newer version');\n  }\n\n  // Set injection state\n  kWindow.keepkeyInjectionState = injectionState;\n\n  console.log(TAG, `Initializing KeepKey Injection v${VERSION}`);\n\n  // Enhanced source information\n  const SOURCE_INFO = {\n    siteUrl: window.location.href,\n    scriptSource: 'KeepKey Extension',\n    version: VERSION,\n    injectedTime: new Date().toISOString(),\n    origin: window.location.origin,\n    protocol: window.location.protocol\n  };\n\n  let messageId = 0;\n  const callbacks = new Map<number, WalletCallback>();\n  const messageQueue: WalletMessage[] = [];\n  let isContentScriptReady = false;\n\n  // Cleanup old callbacks periodically\n  const cleanupCallbacks = () => {\n    const now = Date.now();\n    callbacks.forEach((callback, id) => {\n      if (now - callback.timestamp > CALLBACK_TIMEOUT) {\n        console.warn(TAG, `Callback timeout for request ${id} (${callback.method})`);\n        callback.callback(new Error('Request timeout'));\n        callbacks.delete(id);\n      }\n    });\n  };\n\n  setInterval(cleanupCallbacks, 5000);\n\n  // Manage message queue size\n  const addToQueue = (message: WalletMessage) => {\n    if (messageQueue.length >= MESSAGE_QUEUE_MAX) {\n      console.warn(TAG, 'Message queue full, removing oldest message');\n      messageQueue.shift();\n    }\n    messageQueue.push(message);\n  };\n\n  // Process queued messages when content script becomes ready\n  const processQueue = () => {\n    if (!isContentScriptReady) return;\n    \n    while (messageQueue.length > 0) {\n      const message = messageQueue.shift();\n      if (message) {\n        window.postMessage(message, window.location.origin);\n      }\n    }\n  };\n\n  // Verify injection with content script\n  const verifyInjection = (retryCount = 0): Promise<boolean> => {\n    return new Promise((resolve) => {\n      const verifyId = ++messageId;\n      const timeout = setTimeout(() => {\n        if (retryCount < MAX_RETRY_COUNT) {\n          console.log(TAG, `Verification attempt ${retryCount + 1} failed, retrying...`);\n          setTimeout(() => {\n            verifyInjection(retryCount + 1).then(resolve);\n          }, RETRY_DELAY * Math.pow(2, retryCount)); // Exponential backoff\n        } else {\n          console.error(TAG, 'Failed to verify injection after max retries');\n          injectionState.lastError = 'Failed to verify injection';\n          resolve(false);\n        }\n      }, 1000);\n\n      const handleVerification = (event: MessageEvent) => {\n        if (\n          event.source === window &&\n          event.data?.source === 'keepkey-content' &&\n          event.data?.type === 'INJECTION_CONFIRMED' &&\n          event.data?.requestId === verifyId\n        ) {\n          clearTimeout(timeout);\n          window.removeEventListener('message', handleVerification);\n          isContentScriptReady = true;\n          injectionState.isInjected = true;\n          console.log(TAG, 'Injection verified successfully');\n          processQueue();\n          resolve(true);\n        }\n      };\n\n      window.addEventListener('message', handleVerification);\n\n      // Send verification request\n      window.postMessage({\n        source: 'keepkey-injected',\n        type: 'INJECTION_VERIFY',\n        requestId: verifyId,\n        version: VERSION,\n        timestamp: Date.now()\n      } as WalletMessage, window.location.origin);\n    });\n  };\n\n  // Enhanced wallet request with validation\n  function walletRequest(\n    method: string, \n    params: any[] = [], \n    chain: ChainType, \n    callback: (error: any, result?: any) => void\n  ) {\n    const tag = TAG + ' | walletRequest | ';\n    \n    // Validate inputs\n    if (!method || typeof method !== 'string') {\n      console.error(tag, 'Invalid method:', method);\n      callback(new Error('Invalid method'));\n      return;\n    }\n\n    if (!Array.isArray(params)) {\n      console.warn(tag, 'Params not an array, wrapping:', params);\n      params = [params];\n    }\n\n    try {\n      const requestId = ++messageId;\n      const requestInfo: WalletRequestInfo = {\n        id: requestId,\n        method,\n        params,\n        chain,\n        siteUrl: SOURCE_INFO.siteUrl,\n        scriptSource: SOURCE_INFO.scriptSource,\n        version: SOURCE_INFO.version,\n        requestTime: new Date().toISOString(),\n        referrer: document.referrer,\n        href: window.location.href,\n        userAgent: navigator.userAgent,\n        platform: navigator.platform,\n        language: navigator.language,\n      };\n\n      // Store callback with metadata\n      callbacks.set(requestId, {\n        callback,\n        timestamp: Date.now(),\n        method\n      });\n\n      const message: WalletMessage = {\n        source: 'keepkey-injected',\n        type: 'WALLET_REQUEST',\n        requestId,\n        requestInfo,\n        timestamp: Date.now()\n      };\n\n      if (isContentScriptReady) {\n        window.postMessage(message, window.location.origin);\n      } else {\n        console.log(tag, 'Content script not ready, queueing request');\n        addToQueue(message);\n      }\n    } catch (error) {\n      console.error(tag, 'Error in walletRequest:', error);\n      callback(error);\n    }\n  }\n\n  // Listen for responses with enhanced validation\n  window.addEventListener('message', (event: MessageEvent) => {\n    const tag = TAG + ' | message | ';\n    \n    // Security: Validate origin\n    if (event.source !== window) return;\n    \n    const data = event.data as WalletMessage;\n    if (!data || typeof data !== 'object') return;\n\n    // Handle injection confirmation\n    if (data.source === 'keepkey-content' && data.type === 'INJECTION_CONFIRMED') {\n      isContentScriptReady = true;\n      processQueue();\n      return;\n    }\n\n    // Handle wallet responses\n    if (data.source === 'keepkey-content' && data.type === 'WALLET_RESPONSE' && data.requestId) {\n      const callback = callbacks.get(data.requestId);\n      if (callback) {\n        if (data.error) {\n          callback.callback(data.error);\n        } else {\n          callback.callback(null, data.result);\n        }\n        callbacks.delete(data.requestId);\n      } else {\n        console.warn(tag, 'No callback found for requestId:', data.requestId);\n      }\n    }\n  });\n\n  // Create wallet provider with proper typing\n  function createWalletObject(chain: ChainType): WalletProvider {\n    console.log(TAG, 'Creating wallet object for chain:', chain);\n    \n    const wallet: WalletProvider = {\n      network: 'mainnet',\n      isKeepKey: true,\n      isMetaMask: true,\n      isConnected: isContentScriptReady,\n      \n      request: ({ method, params = [] }) => {\n        return new Promise((resolve, reject) => {\n          walletRequest(method, params, chain, (error, result) => {\n            if (error) {\n              reject(error);\n            } else {\n              resolve(result);\n            }\n          });\n        });\n      },\n\n      send: (payload: any, param1?: any, callback?: any) => {\n        if (!payload.chain) {\n          payload.chain = chain;\n        }\n        \n        if (typeof callback === 'function') {\n          // Async send\n          walletRequest(payload.method, payload.params || param1, chain, (error, result) => {\n            if (error) {\n              callback(error);\n            } else {\n              callback(null, { id: payload.id, jsonrpc: '2.0', result });\n            }\n          });\n        } else {\n          // Sync send (deprecated, but required for compatibility)\n          console.warn(TAG, 'Synchronous send is deprecated and may not work properly');\n          return { id: payload.id, jsonrpc: '2.0', result: null };\n        }\n      },\n\n      sendAsync: (payload: any, param1?: any, callback?: any) => {\n        if (!payload.chain) {\n          payload.chain = chain;\n        }\n        \n        const cb = callback || param1;\n        if (typeof cb !== 'function') {\n          console.error(TAG, 'sendAsync requires a callback function');\n          return;\n        }\n        \n        walletRequest(payload.method, payload.params || param1, chain, (error, result) => {\n          if (error) {\n            cb(error);\n          } else {\n            cb(null, { id: payload.id, jsonrpc: '2.0', result });\n          }\n        });\n      },\n\n      on: (event: string, handler: Function) => {\n        window.addEventListener(event, handler as EventListener);\n      },\n\n      removeListener: (event: string, handler: Function) => {\n        window.removeEventListener(event, handler as EventListener);\n      },\n\n      removeAllListeners: () => {\n        // This would require tracking all listeners\n        console.warn(TAG, 'removeAllListeners not fully implemented');\n      }\n    };\n\n    // Add chain-specific properties\n    if (chain === 'ethereum') {\n      wallet.chainId = '0x1';\n      wallet.networkVersion = '1';\n    }\n\n    return wallet;\n  }\n\n  // EIP-6963 Provider Announcement\n  function announceProvider(ethereumProvider: WalletProvider) {\n    const info: ProviderInfo = {\n      uuid: '350670db-19fa-4704-a166-e52e178b59d4',\n      name: 'KeepKey Client',\n      icon: 'https://pioneers.dev/coins/keepkey.png',\n      rdns: 'com.keepkey',\n    };\n\n    const announceEvent = new CustomEvent('eip6963:announceProvider', {\n      detail: Object.freeze({ info, provider: ethereumProvider }),\n    });\n\n    console.log(TAG, 'Announcing EIP-6963 provider');\n    window.dispatchEvent(announceEvent);\n  }\n\n  // Mount wallet with proper state management\n  async function mountWallet() {\n    const tag = TAG + ' | mountWallet | ';\n    console.log(tag, 'Starting wallet mount process');\n\n    // Wait for injection verification\n    const verified = await verifyInjection();\n    if (!verified) {\n      console.error(tag, 'Failed to verify injection, wallet features may not work');\n      // Continue anyway for compatibility, but flag the issue\n      injectionState.lastError = 'Injection not verified';\n    }\n\n    // Create wallet objects\n    const ethereum = createWalletObject('ethereum');\n    const xfi: Record<string, WalletProvider> = {\n      binance: createWalletObject('binance'),\n      bitcoin: createWalletObject('bitcoin'),\n      bitcoincash: createWalletObject('bitcoincash'),\n      dogecoin: createWalletObject('dogecoin'),\n      dash: createWalletObject('dash'),\n      ethereum: ethereum,\n      keplr: createWalletObject('keplr'),\n      litecoin: createWalletObject('litecoin'),\n      thorchain: createWalletObject('thorchain'),\n      mayachain: createWalletObject('mayachain'),\n    };\n\n    const keepkey: Record<string, WalletProvider> = {\n      binance: createWalletObject('binance'),\n      bitcoin: createWalletObject('bitcoin'),\n      bitcoincash: createWalletObject('bitcoincash'),\n      dogecoin: createWalletObject('dogecoin'),\n      dash: createWalletObject('dash'),\n      ethereum: ethereum,\n      osmosis: createWalletObject('osmosis'),\n      cosmos: createWalletObject('cosmos'),\n      litecoin: createWalletObject('litecoin'),\n      thorchain: createWalletObject('thorchain'),\n      mayachain: createWalletObject('mayachain'),\n      ripple: createWalletObject('ripple'),\n    };\n\n    // Mount providers with conflict detection\n    const mountProvider = (name: string, provider: any) => {\n      if ((kWindow as any)[name]) {\n        console.warn(tag, `${name} already exists, checking if override is allowed`);\n        // TODO: Add user preference check here\n      }\n      \n      try {\n        Object.defineProperty(kWindow, name, {\n          value: provider,\n          writable: false,\n          configurable: true, // Allow reconfiguration for updates\n        });\n        console.log(tag, `Successfully mounted window.${name}`);\n      } catch (e) {\n        console.error(tag, `Failed to mount window.${name}:`, e);\n        injectionState.lastError = `Failed to mount ${name}`;\n      }\n    };\n\n    // Mount providers\n    mountProvider('ethereum', ethereum);\n    mountProvider('xfi', xfi);\n    mountProvider('keepkey', keepkey);\n\n    // Announce EIP-6963 provider\n    announceProvider(ethereum);\n\n    // Listen for re-announcement requests\n    window.addEventListener('eip6963:requestProvider', () => {\n      console.log(tag, 'Re-announcing provider on request');\n      announceProvider(ethereum);\n    });\n\n    // Handle chain changes and other events\n    window.addEventListener('message', (event: MessageEvent) => {\n      if (event.data?.type === 'CHAIN_CHANGED' && ethereum.emit) {\n        console.log(tag, 'Chain changed:', event.data);\n        ethereum.emit('chainChanged', event.data.provider?.chainId);\n      }\n    });\n\n    console.log(tag, 'Wallet mount complete');\n  }\n\n  // Initialize based on document state\n  if (document.readyState === 'loading') {\n    document.addEventListener('DOMContentLoaded', mountWallet);\n  } else {\n    // Document already loaded, mount immediately\n    mountWallet();\n  }\n\n  console.log(TAG, 'Injection script loaded and initialized');\n})();"],
  "mappings": "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",
  "names": []
}
 diff --git a/chrome-extension/src/injected/injected.ts b/chrome-extension/src/injected/injected.ts new file mode 100644 index 0000000..cea7036 --- /dev/null +++ b/chrome-extension/src/injected/injected.ts @@ -0,0 +1,450 @@ +import type { + WalletRequestInfo, + WalletMessage, + ProviderInfo, + WalletCallback, + InjectionState, + ChainType, + WalletProvider, + KeepKeyWindow, +} from './types'; + +(function () { + const TAG = ' | KeepKeyInjected | '; + const VERSION = '2.0.0'; + const MAX_RETRY_COUNT = 3; + const RETRY_DELAY = 100; // ms + const CALLBACK_TIMEOUT = 30000; // 30 seconds + const MESSAGE_QUEUE_MAX = 100; + + const kWindow = window as KeepKeyWindow; + + // Enhanced injection state tracking + const injectionState: InjectionState = { + isInjected: false, + version: VERSION, + injectedAt: Date.now(), + retryCount: 0, + }; + + // Check for existing injection with version comparison + if (kWindow.keepkeyInjectionState) { + const existing = kWindow.keepkeyInjectionState; + console.warn(TAG, `Existing injection detected v${existing.version}, current v${VERSION}`); + + // Only skip if same or newer version + if (existing.version >= VERSION) { + console.log(TAG, 'Skipping injection, newer or same version already present'); + return; + } + console.log(TAG, 'Upgrading injection to newer version'); + } + + // Set injection state + kWindow.keepkeyInjectionState = injectionState; + + console.log(TAG, `Initializing KeepKey Injection v${VERSION}`); + + // Enhanced source information + const SOURCE_INFO = { + siteUrl: window.location.href, + scriptSource: 'KeepKey Extension', + version: VERSION, + injectedTime: new Date().toISOString(), + origin: window.location.origin, + protocol: window.location.protocol, + }; + + let messageId = 0; + const callbacks = new Map(); + const messageQueue: WalletMessage[] = []; + let isContentScriptReady = false; + + // Cleanup old callbacks periodically + const cleanupCallbacks = () => { + const now = Date.now(); + callbacks.forEach((callback, id) => { + if (now - callback.timestamp > CALLBACK_TIMEOUT) { + console.warn(TAG, `Callback timeout for request ${id} (${callback.method})`); + callback.callback(new Error('Request timeout')); + callbacks.delete(id); + } + }); + }; + + setInterval(cleanupCallbacks, 5000); + + // Manage message queue size + const addToQueue = (message: WalletMessage) => { + if (messageQueue.length >= MESSAGE_QUEUE_MAX) { + console.warn(TAG, 'Message queue full, removing oldest message'); + messageQueue.shift(); + } + messageQueue.push(message); + }; + + // Process queued messages when content script becomes ready + const processQueue = () => { + if (!isContentScriptReady) return; + + while (messageQueue.length > 0) { + const message = messageQueue.shift(); + if (message) { + window.postMessage(message, window.location.origin); + } + } + }; + + // Verify injection with content script + const verifyInjection = (retryCount = 0): Promise => { + return new Promise(resolve => { + const verifyId = ++messageId; + const timeout = setTimeout(() => { + if (retryCount < MAX_RETRY_COUNT) { + console.log(TAG, `Verification attempt ${retryCount + 1} failed, retrying...`); + setTimeout( + () => { + verifyInjection(retryCount + 1).then(resolve); + }, + RETRY_DELAY * Math.pow(2, retryCount), + ); // Exponential backoff + } else { + console.error(TAG, 'Failed to verify injection after max retries'); + injectionState.lastError = 'Failed to verify injection'; + resolve(false); + } + }, 1000); + + const handleVerification = (event: MessageEvent) => { + if ( + event.source === window && + event.data?.source === 'keepkey-content' && + event.data?.type === 'INJECTION_CONFIRMED' && + event.data?.requestId === verifyId + ) { + clearTimeout(timeout); + window.removeEventListener('message', handleVerification); + isContentScriptReady = true; + injectionState.isInjected = true; + console.log(TAG, 'Injection verified successfully'); + processQueue(); + resolve(true); + } + }; + + window.addEventListener('message', handleVerification); + + // Send verification request + window.postMessage( + { + source: 'keepkey-injected', + type: 'INJECTION_VERIFY', + requestId: verifyId, + version: VERSION, + timestamp: Date.now(), + } as WalletMessage, + window.location.origin, + ); + }); + }; + + // Enhanced wallet request with validation + function walletRequest( + method: string, + params: any[] = [], + chain: ChainType, + callback: (error: any, result?: any) => void, + ) { + const tag = TAG + ' | walletRequest | '; + + // Validate inputs + if (!method || typeof method !== 'string') { + console.error(tag, 'Invalid method:', method); + callback(new Error('Invalid method')); + return; + } + + if (!Array.isArray(params)) { + console.warn(tag, 'Params not an array, wrapping:', params); + params = [params]; + } + + try { + const requestId = ++messageId; + const requestInfo: WalletRequestInfo = { + id: requestId, + method, + params, + chain, + siteUrl: SOURCE_INFO.siteUrl, + scriptSource: SOURCE_INFO.scriptSource, + version: SOURCE_INFO.version, + requestTime: new Date().toISOString(), + referrer: document.referrer, + href: window.location.href, + userAgent: navigator.userAgent, + platform: navigator.platform, + language: navigator.language, + }; + + // Store callback with metadata + callbacks.set(requestId, { + callback, + timestamp: Date.now(), + method, + }); + + const message: WalletMessage = { + source: 'keepkey-injected', + type: 'WALLET_REQUEST', + requestId, + requestInfo, + timestamp: Date.now(), + }; + + if (isContentScriptReady) { + window.postMessage(message, window.location.origin); + } else { + console.log(tag, 'Content script not ready, queueing request'); + addToQueue(message); + } + } catch (error) { + console.error(tag, 'Error in walletRequest:', error); + callback(error); + } + } + + // Listen for responses with enhanced validation + window.addEventListener('message', (event: MessageEvent) => { + const tag = TAG + ' | message | '; + + // Security: Validate origin + if (event.source !== window) return; + + const data = event.data as WalletMessage; + if (!data || typeof data !== 'object') return; + + // Handle injection confirmation + if (data.source === 'keepkey-content' && data.type === 'INJECTION_CONFIRMED') { + isContentScriptReady = true; + processQueue(); + return; + } + + // Handle wallet responses + if (data.source === 'keepkey-content' && data.type === 'WALLET_RESPONSE' && data.requestId) { + const callback = callbacks.get(data.requestId); + if (callback) { + if (data.error) { + callback.callback(data.error); + } else { + callback.callback(null, data.result); + } + callbacks.delete(data.requestId); + } else { + console.warn(tag, 'No callback found for requestId:', data.requestId); + } + } + }); + + // Create wallet provider with proper typing + function createWalletObject(chain: ChainType): WalletProvider { + console.log(TAG, 'Creating wallet object for chain:', chain); + + const wallet: WalletProvider = { + network: 'mainnet', + isKeepKey: true, + isMetaMask: true, + isConnected: isContentScriptReady, + + request: ({ method, params = [] }) => { + return new Promise((resolve, reject) => { + walletRequest(method, params, chain, (error, result) => { + if (error) { + reject(error); + } else { + resolve(result); + } + }); + }); + }, + + send: (payload: any, param1?: any, callback?: any) => { + if (!payload.chain) { + payload.chain = chain; + } + + if (typeof callback === 'function') { + // Async send + walletRequest(payload.method, payload.params || param1, chain, (error, result) => { + if (error) { + callback(error); + } else { + callback(null, { id: payload.id, jsonrpc: '2.0', result }); + } + }); + } else { + // Sync send (deprecated, but required for compatibility) + console.warn(TAG, 'Synchronous send is deprecated and may not work properly'); + return { id: payload.id, jsonrpc: '2.0', result: null }; + } + }, + + sendAsync: (payload: any, param1?: any, callback?: any) => { + if (!payload.chain) { + payload.chain = chain; + } + + const cb = callback || param1; + if (typeof cb !== 'function') { + console.error(TAG, 'sendAsync requires a callback function'); + return; + } + + walletRequest(payload.method, payload.params || param1, chain, (error, result) => { + if (error) { + cb(error); + } else { + cb(null, { id: payload.id, jsonrpc: '2.0', result }); + } + }); + }, + + on: (event: string, handler: Function) => { + window.addEventListener(event, handler as EventListener); + }, + + removeListener: (event: string, handler: Function) => { + window.removeEventListener(event, handler as EventListener); + }, + + removeAllListeners: () => { + // This would require tracking all listeners + console.warn(TAG, 'removeAllListeners not fully implemented'); + }, + }; + + // Add chain-specific properties + if (chain === 'ethereum') { + wallet.chainId = '0x1'; + wallet.networkVersion = '1'; + } + + return wallet; + } + + // EIP-6963 Provider Announcement + function announceProvider(ethereumProvider: WalletProvider) { + const info: ProviderInfo = { + uuid: '350670db-19fa-4704-a166-e52e178b59d4', + name: 'KeepKey Client', + icon: 'https://pioneers.dev/coins/keepkey.png', + rdns: 'com.keepkey', + }; + + const announceEvent = new CustomEvent('eip6963:announceProvider', { + detail: Object.freeze({ info, provider: ethereumProvider }), + }); + + console.log(TAG, 'Announcing EIP-6963 provider'); + window.dispatchEvent(announceEvent); + } + + // Mount wallet with proper state management + async function mountWallet() { + const tag = TAG + ' | mountWallet | '; + console.log(tag, 'Starting wallet mount process'); + + // Wait for injection verification + const verified = await verifyInjection(); + if (!verified) { + console.error(tag, 'Failed to verify injection, wallet features may not work'); + // Continue anyway for compatibility, but flag the issue + injectionState.lastError = 'Injection not verified'; + } + + // Create wallet objects + const ethereum = createWalletObject('ethereum'); + const xfi: Record = { + binance: createWalletObject('binance'), + bitcoin: createWalletObject('bitcoin'), + bitcoincash: createWalletObject('bitcoincash'), + dogecoin: createWalletObject('dogecoin'), + dash: createWalletObject('dash'), + ethereum: ethereum, + keplr: createWalletObject('keplr'), + litecoin: createWalletObject('litecoin'), + thorchain: createWalletObject('thorchain'), + mayachain: createWalletObject('mayachain'), + }; + + const keepkey: Record = { + binance: createWalletObject('binance'), + bitcoin: createWalletObject('bitcoin'), + bitcoincash: createWalletObject('bitcoincash'), + dogecoin: createWalletObject('dogecoin'), + dash: createWalletObject('dash'), + ethereum: ethereum, + osmosis: createWalletObject('osmosis'), + cosmos: createWalletObject('cosmos'), + litecoin: createWalletObject('litecoin'), + thorchain: createWalletObject('thorchain'), + mayachain: createWalletObject('mayachain'), + ripple: createWalletObject('ripple'), + }; + + // Mount providers with conflict detection + const mountProvider = (name: string, provider: any) => { + if ((kWindow as any)[name]) { + console.warn(tag, `${name} already exists, checking if override is allowed`); + // TODO: Add user preference check here + } + + try { + Object.defineProperty(kWindow, name, { + value: provider, + writable: false, + configurable: true, // Allow reconfiguration for updates + }); + console.log(tag, `Successfully mounted window.${name}`); + } catch (e) { + console.error(tag, `Failed to mount window.${name}:`, e); + injectionState.lastError = `Failed to mount ${name}`; + } + }; + + // Mount providers + mountProvider('ethereum', ethereum); + mountProvider('xfi', xfi); + mountProvider('keepkey', keepkey); + + // Announce EIP-6963 provider + announceProvider(ethereum); + + // Listen for re-announcement requests + window.addEventListener('eip6963:requestProvider', () => { + console.log(tag, 'Re-announcing provider on request'); + announceProvider(ethereum); + }); + + // Handle chain changes and other events + window.addEventListener('message', (event: MessageEvent) => { + if (event.data?.type === 'CHAIN_CHANGED' && ethereum.emit) { + console.log(tag, 'Chain changed:', event.data); + ethereum.emit('chainChanged', event.data.provider?.chainId); + } + }); + + console.log(tag, 'Wallet mount complete'); + } + + // Initialize based on document state + if (document.readyState === 'loading') { + document.addEventListener('DOMContentLoaded', mountWallet); + } else { + // Document already loaded, mount immediately + mountWallet(); + } + + console.log(TAG, 'Injection script loaded and initialized'); +})(); diff --git a/chrome-extension/src/injected/types.ts b/chrome-extension/src/injected/types.ts new file mode 100644 index 0000000..bc74674 --- /dev/null +++ b/chrome-extension/src/injected/types.ts @@ -0,0 +1,88 @@ +// Type definitions for the injected script + +export interface WalletRequestInfo { + id: number; + method: string; + params: any[]; + chain: string; + siteUrl: string; + scriptSource: string; + version: string; + requestTime: string; + referrer: string; + href: string; + userAgent: string; + platform: string; + language: string; +} + +export interface WalletMessage { + source: 'keepkey-injected' | 'keepkey-content'; + type: 'WALLET_REQUEST' | 'WALLET_RESPONSE' | 'INJECTION_CONFIRMED' | 'INJECTION_VERIFY'; + requestId?: number; + requestInfo?: WalletRequestInfo; + result?: any; + error?: any; + version?: string; + timestamp?: number; +} + +export interface ProviderInfo { + uuid: string; + name: string; + icon: string; + rdns: string; +} + +export interface WalletCallback { + callback: (error: any, result?: any) => void; + timestamp: number; + method: string; +} + +export interface InjectionState { + isInjected: boolean; + version: string; + injectedAt: number; + retryCount: number; + lastError?: string; +} + +export type ChainType = + | 'ethereum' + | 'binance' + | 'bitcoin' + | 'bitcoincash' + | 'dogecoin' + | 'dash' + | 'litecoin' + | 'thorchain' + | 'mayachain' + | 'osmosis' + | 'cosmos' + | 'ripple' + | 'keplr'; + +export interface WalletProvider { + network: string; + isKeepKey: boolean; + isMetaMask: boolean; + isConnected: boolean; + chainId?: string; + networkVersion?: string; + request: (args: { method: string; params?: any[] }) => Promise; + send: (payload: any, param1?: any, callback?: any) => any; + sendAsync: (payload: any, param1?: any, callback?: any) => any; + on: (event: string, handler: Function) => void; + removeListener: (event: string, handler: Function) => void; + removeAllListeners: () => void; + emit?: (event: string, ...args: any[]) => void; +} + +export interface KeepKeyWindow extends Window { + keepkeyInjected?: boolean; + keepkeyInjectionState?: InjectionState; + ethereum?: WalletProvider; + xfi?: Record; + keepkey?: Record; +} diff --git a/docs/INJECTION_ARCHITECTURE.md b/docs/INJECTION_ARCHITECTURE.md new file mode 100644 index 0000000..6e6850a --- /dev/null +++ b/docs/INJECTION_ARCHITECTURE.md @@ -0,0 +1,205 @@ +# JavaScript Injection Architecture Documentation + +## Current Implementation Overview + +The KeepKey extension uses a multi-layer injection system to provide wallet functionality to web pages. This document details the current architecture, communication flow, and identified reliability issues. + +## Architecture Layers + +### 1. Manifest Declaration (`chrome-extension/manifest.js`) +```javascript +content_scripts: [ + { + matches: ['http://*/*', 'https://*/*', ''], + js: ['content/index.iife.js'], + run_at: 'document_start', // Critical timing issue #1 + }, + { + matches: ['http://*/*', 'https://*/*', ''], + js: ['content-ui/index.iife.js'], + // No run_at specified - defaults to 'document_idle' (timing issue #2) + } +] +``` + +### 2. Content Script (`pages/content/src/index.ts`) +- Runs in isolated context with access to Chrome APIs +- Creates and injects `injected.js` into the page's DOM +- Acts as message bridge between page and background script + +### 3. Injected Script (`chrome-extension/public/injected.js`) +- Runs in page context with direct access to `window` object +- Creates wallet provider objects (`window.ethereum`, `window.xfi`, `window.keepkey`) +- Implements EIP-6963 provider announcement +- Version: 1.0.17 + +## Communication Flow + +```mermaid +graph TD + A[Web Page/dApp] -->|window.ethereum.request| B[Injected Script] + B -->|postMessage| C[Content Script] + C -->|chrome.runtime.sendMessage| D[Background Script] + D -->|Process Request| E[KeepKey Hardware] + E -->|Response| D + D -->|sendResponse| C + C -->|postMessage| B + B -->|Promise resolve| A +``` + +## Detailed Flow Analysis + +### 1. Injection Process +```javascript +// Content script injects the provider script +const script = document.createElement('script'); +script.src = chrome.runtime.getURL('injected.js'); +script.onload = function() { this.remove(); }; // Self-cleaning +(document.head || document.documentElement).appendChild(script); +``` + +### 2. Message Passing Protocol + +#### Request Flow: +1. **dApp → Injected Script**: Direct method call (e.g., `ethereum.request()`) +2. **Injected Script → Content Script**: `window.postMessage` with structure: + ```javascript + { + source: 'keepkey-injected', + type: 'WALLET_REQUEST', + requestId: number, + requestInfo: { + id, method, params, chain, siteUrl, + scriptSource, version, requestTime, ...metadata + } + } + ``` +3. **Content Script → Background**: `chrome.runtime.sendMessage` +4. **Background Processing**: Routes to appropriate chain handler + +#### Response Flow: +Reverse path with `WALLET_RESPONSE` type messages + +## Identified Reliability Issues + +### 🚨 Critical Issues + +#### 1. Race Condition at Page Load +**Problem**: Content script runs at `document_start` but injected script may not be ready when dApp initializes +**Impact**: dApps fail to detect wallet provider +**Current Mitigation**: Multiple mount attempts (lines 318-323 in injected.js) +```javascript +mountWallet(); +if (document.readyState === 'complete' || document.readyState === 'interactive') { + mountWallet(); // Duplicate call - inefficient +} else { + document.addEventListener('DOMContentLoaded', mountWallet); +} +``` + +#### 2. No Injection Verification +**Problem**: No way to confirm successful injection from content script +**Impact**: Silent failures when injection fails + +#### 3. Global Namespace Pollution +**Problem**: Direct modification of `window` object without proper isolation +**Impact**: Conflicts with other extensions/scripts + +#### 4. Message Queue Management +**Problem**: Basic queue implementation without timeout or overflow handling +```javascript +const messageQueue = []; // Unbounded growth potential +``` + +### ⚠️ Moderate Issues + +#### 5. Synchronous Request Handling +**Problem**: `sendRequestSync` function doesn't actually work synchronously +**Impact**: Incompatible with legacy dApps expecting sync responses + +#### 6. Error Handling Gaps +- No retry mechanism for failed injections +- Callbacks can be orphaned if responses never arrive +- No cleanup for stale callbacks + +#### 7. Version Mismatch Detection +**Problem**: No mechanism to detect/handle version mismatches between components +**Current Version**: 1.0.17 hardcoded in injected.js + +#### 8. Duplicate Prevention Logic +```javascript +if (window.keepkeyInjected) return; // Too simplistic +window.keepkeyInjected = true; +``` +**Issue**: Can be bypassed, doesn't handle reload scenarios properly + +### 📊 Performance Issues + +#### 9. Multiple Injection Points +- Three separate content scripts loaded +- Shadow DOM created for UI components (overhead) +- Multiple event listeners without cleanup + +#### 10. Inefficient Provider Creation +- Creates wallet objects for all chains even if unused +- No lazy loading mechanism + +## Security Concerns + +### 1. Unrestricted Message Passing +- Uses `'*'` for postMessage targetOrigin +- No origin validation in message handlers + +### 2. Information Leakage +Extensive metadata collection in requests: +```javascript +requestInfo: { + siteUrl, referrer, href, userAgent, + platform, language // Privacy concerns +} +``` + +### 3. Configuration Exposure +```javascript +const userOverrideSetting = true; // Hardcoded, should be configurable +``` + +## Recommendations for Redesign + +### Immediate Improvements +1. **Add injection confirmation mechanism** + - Content script should verify injection success + - Implement retry logic with exponential backoff + +2. **Improve race condition handling** + - Use MutationObserver to detect when to inject + - Implement proper ready state management + +3. **Add message validation** + - Validate origin and source + - Add message schema validation + +### Architecture Redesign +1. **Use declarative injection** when possible (web_accessible_resources) +2. **Implement proper state machine** for injection lifecycle +3. **Add telemetry** for injection success/failure rates +4. **Create abstraction layer** for multi-chain support +5. **Implement connection pooling** for message passing + +### Code Quality +1. **TypeScript migration** for injected.js +2. **Unit tests** for injection logic +3. **Integration tests** for dApp compatibility +4. **Performance monitoring** for injection timing + +## Testing Scenarios + +Critical test cases for reliable injection: +1. Fast page loads (cached resources) +2. Slow page loads (large assets) +3. Single-page applications (React, Vue, Angular) +4. Page refreshes and navigation +5. Multiple tabs simultaneously +6. Extension update/reload scenarios +7. Conflicting wallet extensions +8. CSP-restricted pages \ No newline at end of file diff --git a/docs/Notes.md b/docs/Notes.md new file mode 100644 index 0000000..290f1d6 --- /dev/null +++ b/docs/Notes.md @@ -0,0 +1,434 @@ +Yeah—this will keep “losing” to MetaMask by design. Two big truths about MV3 + wallets: + +You can’t reliably “win” window.ethereum. Chrome doesn’t guarantee extension execution order, so a race with MetaMask is unwinnable. + +Many sites (Google Sheets/Docs especially) are weird: multiple sandboxed iframes, strict CSP/Trusted Types, and busy message buses. Your current request/response dance with window.postMessage + one-shot callbacks is fragile there. + +Here’s how to make this solid and “MetaMask-friendly”: + +1) Stop trying to be window.ethereum + +Don’t set isMetaMask: true (ever). That makes dapps mis-detect you and can break them. + +Don’t overwrite window.ethereum. You can’t guarantee ordering, and some dapps now ignore non-MetaMask replacements anyway. + +Instead, embrace EIP-6963 (multi-wallet discovery). Many modern dapps already use it. Your injected script should only: + +Expose window.keepkey (nice to have). + +Announce your provider via eip6963:announceProvider. + +Re-announce when the page asks via eip6963:requestProvider. + +Injected (page-world) provider skeleton +(() => { +const info = { +uuid: '350670db-19fa-4704-a166-e52e178b59d4', // keep stable +name: 'KeepKey Client', +icon: 'https://pioneers.dev/coins/keepkey.png', +rdns: 'com.keepkey', +}; + +// Minimal EIP-1193 provider +class KeepKeyProvider { +constructor(chainHint = 'ethereum') { +this._chainHint = chainHint; +this._listeners = new Map(); +this.isKeepKey = true; +this.isMetaMask = false; // important +} +request({ method, params }) { +return new Promise((resolve, reject) => { +window.postMessage({ +source: 'keepkey-injected', +type: 'WALLET_REQUEST', +requestId: crypto.randomUUID(), +requestInfo: { method, params, chain: this._chainHint } +}, window.origin); +const onMsg = (ev) => { +if (ev.source !== window) return; +const d = ev.data; +if (d?.source === 'keepkey-content' && d.type === 'WALLET_RESPONSE' && d.req?.method === method) { +window.removeEventListener('message', onMsg); +d.error ? reject(d.error) : resolve(d.result); +} +}; +window.addEventListener('message', onMsg); +}); +} +on(event, handler) { +const arr = this._listeners.get(event) || []; +arr.push(handler); +this._listeners.set(event, arr); +} +removeListener(event, handler) { +const arr = this._listeners.get(event) || []; +this._listeners.set(event, arr.filter(h => h !== handler)); +} +_emit(event, payload) { +(this._listeners.get(event) || []).forEach(h => { try { h(payload); } catch {} }); +} +} + +const provider = new KeepKeyProvider('ethereum'); + +// Optional: expose window.keepkey (don’t touch window.ethereum) +if (typeof window.keepkey === 'undefined') { +Object.defineProperty(window, 'keepkey', { value: { ethereum: provider }, configurable: false }); +} + +function announce() { +window.dispatchEvent(new CustomEvent('eip6963:announceProvider', { +detail: { info, provider } +})); +} + +// Announce immediately and whenever requested +announce(); +window.addEventListener('eip6963:requestProvider', announce); +})(); + +2) Make your transport reliable (use Ports, not ad-hoc messages) + +chrome.runtime.sendMessage is fine for one-offs, but for wallet traffic you want a persistent Port: + +Less chance of lost messages (esp. on heavy pages like Sheets). + +Easy correlation and back-pressure. + +content-script.js (isolated world) +// Bridge page <-> background with a Port +const port = chrome.runtime.connect({ name: 'keepkey-port' }); + +window.addEventListener('message', (event) => { +if (event.source !== window) return; +const d = event.data; +if (d?.source === 'keepkey-injected' && d.type === 'WALLET_REQUEST') { +port.postMessage({ type: 'WALLET_REQUEST', request: d.requestInfo }); +} +}); + +port.onMessage.addListener((msg) => { +if (msg.type === 'WALLET_RESPONSE') { +window.postMessage({ +source: 'keepkey-content', +type: 'WALLET_RESPONSE', +req: msg.req, // echo back some correlation (e.g., method) +result: msg.result ?? null, +error: msg.error ?? null +}, window.origin); +} +}); + +// Inject page-world script +const s = document.createElement('script'); +s.src = chrome.runtime.getURL('injected.js'); +(document.head || document.documentElement).appendChild(s); +s.remove(); + +background.js +chrome.runtime.onConnect.addListener((port) => { +if (port.name !== 'keepkey-port') return; +port.onMessage.addListener(async (msg) => { +if (msg.type === 'WALLET_REQUEST') { +try { +const result = await handleWalletRequest(msg.request); // your logic +port.postMessage({ type:'WALLET_RESPONSE', req: msg.request, result }); +} catch (error) { +port.postMessage({ type:'WALLET_RESPONSE', req: msg.request, error: serializeErr(error) }); +} +} +}); +}); + +3) Play nice with Google Sheets/Docs + +These pages can be brittle. A few hard-won tips: + +Don’t inject on Docs/Sheets until needed. If you don’t need wallet access there, exclude them: + +"content_scripts": [{ +"matches": ["http://*/*", "https://*/*"], +"exclude_matches": [ +"https://docs.google.com/*", +"https://drive.google.com/*" +], +"js": ["content/index.iife.js"], +"run_at": "document_start" +}] + + +If you do need to support them, use Ports (above) and set targetOrigin to window.origin (you did this in my snippet) instead of '*'. + +Some frames are sandboxed. Consider all_frames: true and gate your injection to window.top === window to avoid flooding subframes; inject the page-world script only in the top frame. + +4) Manifest adjustments that help + +You don’t need to carpet-bomb matches three times. Merge your three content script blocks; load CSS/JS together. + +Consider all_frames: true and run_at: "document_start" (you already have it) so you’re ready when pages probe for wallets early. + +When you occasionally must run code in the MAIN world (instead of isolated) without DOM injection, you can use chrome.scripting.executeScript with { world: 'MAIN' } from the background on demand (manifest needs "scripting" permission). For a default always-on provider, the “inject a