@nockchain/rose 0.1.4-nightly.5

package/extension/shared/first-name-derivation.ts

@@ -0,0 +1,128 @@
+/**
+ * First-name derivation utilities for Nockchain v1 notes
+ *
+ * In Nockchain v1, notes are indexed by "first-names" which are deterministically
+ * derived from their lock conditions. This module provides functions to calculate
+ * the expected first-name for standard lock types (simple PKH and coinbase).
+ */
+
+import * as wasm from '@nockchain/rose-wasm/rose_wasm.js';
+import { initIrisSdkOnce } from './wasm-utils.js';
+
+/**
+ * Derives the first-name for a simple PKH-locked note
+ *
+ * This is used for regular transaction outputs (non-coinbase).
+ * The lock structure is: [(pkh, m=1, hashes=[your_pkh])]
+ *
+ * @param pkhBase58 - The base58-encoded PKH digest (~55 chars)
+ * @returns The base58-encoded first-name hash (40 bytes encoded)
+ *
+ * @example
+ * ```typescript
+ * const myPKH = "2R7Z8p..."; // Your v1 PKH address
+ * const firstName = await deriveSimpleFirstName(myPKH);
+ * // Use firstName to query notes via gRPC API
+ * ```
+ */
+export async function deriveSimpleFirstName(pkhBase58: string): Promise<string> {
+  await initIrisSdkOnce();
+
+  // Validate PKH is a non-empty string
+  if (!pkhBase58 || typeof pkhBase58 !== 'string') {
+    throw new Error('PKH must be a non-empty base58 string');
+  }
+
+  // Create a simple PKH-only spend condition
+  const pkh = wasm.Pkh.single(pkhBase58);
+  const condition = wasm.SpendCondition.newPkh(pkh);
+
+  // Get the first-name from the spend condition
+  const firstNameDigest = condition.firstName();
+  const firstNameBase58 = firstNameDigest.value;
+
+  // Verify it's the right length (40 bytes → ~55 chars base58)
+  if (firstNameBase58.length < 50 || firstNameBase58.length > 60) {
+    console.warn(
+      `[First-Name] ⚠️ WARNING: First-name length ${firstNameBase58.length} is outside expected range 50-60 chars`
+    );
+  }
+
+  return firstNameBase58;
+}
+
+/**
+ * Derives the first-name for a coinbase (mining reward) note
+ *
+ * This is used for mining rewards which include both a PKH lock and a timelock.
+ * The lock structure is: [(pkh, m=1, hashes=[your_pkh]), (tim, timelock)]
+ *
+ * @param pkhBase58 - The base58-encoded PKH digest (~55 chars)
+ * @returns The base58-encoded first-name hash (40 bytes encoded)
+ *
+ * @example
+ * ```typescript
+ * const myPKH = "2R7Z8p..."; // Your v1 PKH address
+ * const firstName = await deriveCoinbaseFirstName(myPKH);
+ * // Use firstName to query mining rewards via gRPC API
+ * ```
+ */
+export async function deriveCoinbaseFirstName(pkhBase58: string): Promise<string> {
+  await initIrisSdkOnce();
+
+  // Validate PKH is a non-empty string
+  if (!pkhBase58 || typeof pkhBase58 !== 'string') {
+    throw new Error('PKH must be a non-empty base58 string');
+  }
+
+  // Create PKH + TIM (coinbase) spend condition
+  const pkhLeaf = wasm.LockPrimitive.newPkh(wasm.Pkh.single(pkhBase58));
+  const timLeaf = wasm.LockPrimitive.newTim(wasm.LockTim.coinbase());
+  const condition = new wasm.SpendCondition([pkhLeaf, timLeaf]);
+
+  // Get the first-name from the spend condition
+  const firstNameDigest = condition.firstName();
+  const firstNameBase58 = firstNameDigest.value;
+
+  // Verify it's the right length (40 bytes → ~55 chars base58)
+  if (firstNameBase58.length < 50 || firstNameBase58.length > 60) {
+    console.warn(
+      `[First-Name] Coinbase first-name length ${firstNameBase58.length} is outside expected range 50-60 chars`
+    );
+  }
+
+  return firstNameBase58;
+}
+
+/**
+ * Helper to get both first-names for a given PKH address
+ *
+ * Returns both simple and coinbase first-names so you can query
+ * both regular transaction outputs and mining rewards in a single call.
+ *
+ * @param pkhBase58 - The base58-encoded PKH address (~55 chars)
+ * @returns Object containing both first-names
+ *
+ * @example
+ * ```typescript
+ * const myPKH = "2R7Z8p...";
+ * const { simple, coinbase } = await getBothFirstNames(myPKH);
+ *
+ * // Query both types of notes
+ * const [simpleNotes, coinbaseNotes] = await Promise.all([
+ *   queryNotesByFirstName(simple),
+ *   queryNotesByFirstName(coinbase),
+ * ]);
+ * ```
+ */
+export async function getBothFirstNames(pkhBase58: string): Promise<{
+  simple: string;
+  coinbase: string;
+}> {
+  await initIrisSdkOnce();
+
+  return {
+    simple: await deriveSimpleFirstName(pkhBase58),
+    coinbase: await deriveCoinbaseFirstName(pkhBase58),
+  };
+}

package/extension/shared/keyfile.ts

@@ -0,0 +1,58 @@
+/**
+ * Keyfile import/export utilities
+ * Plain JSON format for backup/restore
+ */
+
+export interface Keyfile {
+  version: string;
+  mnemonic: string;
+  created: string;
+}
+
+/**
+ * Export mnemonic to plain JSON keyfile
+ */
+export function exportKeyfile(mnemonic: string): Keyfile {
+  return {
+    version: '1',
+    mnemonic,
+    created: new Date().toISOString(),
+  };
+}
+
+/**
+ * Import keyfile to get mnemonic
+ */
+export function importKeyfile(keyfile: Keyfile): string {
+  // Validate keyfile format
+  if (!keyfile.version) {
+    throw new Error('Invalid keyfile format: missing version');
+  }
+
+  if (keyfile.version !== '1') {
+    throw new Error('Unsupported keyfile version');
+  }
+
+  if (!keyfile.mnemonic || typeof keyfile.mnemonic !== 'string') {
+    throw new Error('Invalid keyfile format: missing or invalid mnemonic');
+  }
+
+  return keyfile.mnemonic;
+}
+
+/**
+ * Download keyfile as JSON file
+ */
+export function downloadKeyfile(keyfile: Keyfile, filename: string = 'nockchain-keyfile.json') {
+  const json = JSON.stringify(keyfile, null, 2);
+  const blob = new Blob([json], { type: 'application/json' });
+  const url = URL.createObjectURL(blob);
+
+  const a = document.createElement('a');
+  a.href = url;
+  a.download = filename;
+  document.body.appendChild(a);
+  a.click();
+  document.body.removeChild(a);
+  URL.revokeObjectURL(url);
+}

package/extension/shared/onboarding.ts

@@ -0,0 +1,78 @@
+/**
+ * Onboarding State Management
+ * Handles persisting and retrieving onboarding progress to ensure users
+ * complete their secret phrase backup even if they close the popup mid-flow.
+ */
+
+import { STORAGE_KEYS } from './constants';
+
+function isRecord(x: unknown): x is Record<string, unknown> {
+  return typeof x === 'object' && x !== null;
+}
+
+/**
+ * Onboarding state stored in chrome.storage.local
+ */
+export interface OnboardingState {
+  /** Whether secret phrase backup has been completed */
+  completed: boolean;
+  /** Current onboarding step (only present if not completed) */
+  step?: 'backup' | 'verify';
+}
+
+/**
+ * Set the onboarding state to in-progress at the backup step
+ * Called when a new wallet is created
+ */
+export async function setOnboardingInProgress(): Promise<void> {
+  const state: OnboardingState = {
+    completed: false,
+    step: 'backup',
+  };
+  await chrome.storage.local.set({ [STORAGE_KEYS.ONBOARDING_STATE]: state });
+}
+
+/**
+ * Mark onboarding as complete
+ * Called when user successfully verifies their secret phrase
+ */
+export async function markOnboardingComplete(): Promise<void> {
+  const state: OnboardingState = {
+    completed: true,
+  };
+  await chrome.storage.local.set({ [STORAGE_KEYS.ONBOARDING_STATE]: state });
+}
+
+/**
+ * Get current onboarding state
+ * Returns null if no onboarding state exists (fresh install or pre-migration)
+ */
+export async function getOnboardingState(): Promise<OnboardingState | null> {
+  const result = (await chrome.storage.local.get([STORAGE_KEYS.ONBOARDING_STATE])) as Record<
+    string,
+    unknown
+  >;
+  const raw = result[STORAGE_KEYS.ONBOARDING_STATE];
+  if (!isRecord(raw)) return null;
+  if (typeof raw.completed !== 'boolean') return null;
+  const step = raw.step;
+  if (step === 'backup' || step === 'verify') return { completed: raw.completed, step };
+  if (step === undefined) return { completed: raw.completed };
+  return null;
+}
+
+/**
+ * Check if user has incomplete onboarding (created wallet but didn't complete backup)
+ */
+export async function hasIncompleteOnboarding(): Promise<boolean> {
+  const state = await getOnboardingState();
+  return state !== null && !state.completed;
+}
+
+/**
+ * Clear onboarding state
+ * Used if user explicitly skips backup (not recommended) or for cleanup
+ */
+export async function clearOnboardingState(): Promise<void> {
+  await chrome.storage.local.remove(STORAGE_KEYS.ONBOARDING_STATE);
+}

package/extension/shared/price-api.ts

@@ -0,0 +1,79 @@
+/**
+ * Price API for fetching NOCK token price from CoinGecko
+ */
+
+// CoinGecko API configuration
+const COINGECKO_API_BASE = 'https://api.coingecko.com/api/v3';
+
+const NOCK_COIN_ID = 'nockchain';
+
+export interface PriceData {
+  usd: number;
+  usd_24h_change: number;
+}
+
+/**
+ * Fetch current NOCK price from CoinGecko
+ * @returns Price in USD and 24h change percentage
+ */
+export async function fetchNockPrice(): Promise<PriceData> {
+  try {
+    const response = await fetch(
+      `${COINGECKO_API_BASE}/simple/price?ids=${NOCK_COIN_ID}&vs_currencies=usd&include_24hr_change=true`
+    );
+
+    if (!response.ok) {
+      throw new Error(`CoinGecko API error: ${response.status}`);
+    }
+
+    const data = await response.json();
+
+    // Check if the coin exists in the response
+    if (!data[NOCK_COIN_ID]) {
+      throw new Error(`Coin ${NOCK_COIN_ID} not found on CoinGecko`);
+    }
+
+    const coinData = data[NOCK_COIN_ID];
+
+    return {
+      usd: coinData.usd || 0,
+      usd_24h_change: coinData.usd_24h_change || 0,
+    };
+  } catch (error) {
+    console.error('[PriceAPI] Failed to fetch price:', error);
+
+    // Return fallback data instead of throwing
+    // This prevents the UI from breaking if the API is down
+    return {
+      usd: 0,
+      usd_24h_change: 0,
+    };
+  }
+}
+
+/**
+ * Format price for display
+ * @param price - Price in USD
+ * @returns Formatted price string (e.g., "$1.23")
+ */
+export function formatPrice(price: number): string {
+  if (price === 0) return '$0.00';
+
+  // For prices < $0.01, show more decimals
+  if (price < 0.01) {
+    return `$${price.toFixed(6)}`;
+  }
+
+  // For normal prices, show 2 decimals
+  return `$${price.toFixed(2)}`;
+}
+
+/**
+ * Format percentage change for display
+ * @param change - Percentage change
+ * @returns Formatted percentage string (e.g., "+5.23%")
+ */
+export function formatPercentChange(change: number): string {
+  const formatted = Math.abs(change).toFixed(2);
+  return change >= 0 ? `+${formatted}%` : `-${formatted}%`;
+}

package/extension/shared/rpc-client-browser.ts

@@ -0,0 +1,315 @@
+/**
+ * Browser gRPC-web client for Nockchain
+ * Uses WASM-based tonic-web-wasm-client for proper bigint handling
+ */
+
+import { GrpcClient } from '@nockchain/rose-wasm/rose_wasm.js';
+import type { Note } from './types';
+import { base58 } from '@scure/base';
+import { initIrisSdkOnce } from './wasm-utils.js';
+import { RPC_ENDPOINT, INTERNAL_METHODS } from './constants.js';
+
+/**
+ * Report RPC connection status to background service worker
+ * This updates the connection indicator (green/red dot) in the UI
+ */
+async function reportRpcStatus(healthy: boolean): Promise<void> {
+  try {
+    await chrome.runtime.sendMessage({
+      payload: {
+        method: INTERNAL_METHODS.REPORT_RPC_STATUS,
+        params: [healthy],
+      },
+    });
+  } catch {
+    // Ignore errors - background may not be ready
+  }
+}
+
+/**
+ * Browser RPC client for Nockchain blockchain
+ * Compatible with Chrome extensions and web browsers
+ * Uses Rust WASM client for proper bigint serialization
+ */
+export class NockchainBrowserRPCClient {
+  private client: GrpcClient | null = null;
+  private endpoint: string;
+
+  constructor(endpoint: string = RPC_ENDPOINT) {
+    this.endpoint = endpoint;
+  }
+
+  /**
+   * Ensure the WASM client is initialized
+   */
+  private async ensureClient(): Promise<GrpcClient> {
+    if (this.client) {
+      return this.client;
+    }
+
+    await initIrisSdkOnce();
+    this.client = new GrpcClient(this.endpoint);
+    return this.client;
+  }
+
+  /**
+   * Get balance (UTXOs/notes) for an address
+   * @param address - Base58-encoded V1 address
+   */
+  async getBalance(address: string): Promise<Note[]> {
+    try {
+      const client = await this.ensureClient();
+      const response = await client.getBalanceByAddress(address);
+
+      // Report successful RPC call
+      reportRpcStatus(true);
+
+      return this.convertBalanceToNotes(response);
+    } catch (error) {
+      console.error('[RPC Browser] Error fetching balance:', error);
+      // Report failed RPC call
+      reportRpcStatus(false);
+      throw new Error(
+        `Failed to fetch balance: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  /**
+   * Get notes by first-name (v1 query method)
+   * @param firstNameBase58 - Base58-encoded first-name hash (~55 characters)
+   * @returns Array of notes with matching first-name
+   */
+  async getNotesByFirstName(firstNameBase58: string): Promise<Note[]> {
+    try {
+      const client = await this.ensureClient();
+      const response = await client.getBalanceByFirstName(firstNameBase58);
+
+      // Report successful RPC call
+      reportRpcStatus(true);
+
+      return this.convertBalanceToNotes(response);
+    } catch (error) {
+      console.error('[RPC Browser] Error fetching notes by first-name:', error);
+      // Report failed RPC call
+      reportRpcStatus(false);
+      throw new Error(
+        `Failed to fetch notes by first-name: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  /**
+   * Get current block height from balance query
+   */
+  async getCurrentBlockHeight(address?: string): Promise<bigint> {
+    try {
+      const client = await this.ensureClient();
+      // Use a dummy address to get chain info
+      const dummyAddress = '1'.repeat(132);
+      const response = await client.getBalanceByAddress(dummyAddress);
+
+      if (response.height?.value) {
+        return BigInt(response.height.value);
+      }
+
+      return BigInt(0);
+    } catch (error) {
+      console.error('[RPC Browser] Error getting block height:', error);
+      return BigInt(0);
+    }
+  }
+
+  /**
+   * Send a transaction to the network
+   * @param rawTx - The signed raw transaction object
+   * @returns Transaction ID if successful
+   */
+  async sendTransaction(rawTx: any): Promise<string> {
+    try {
+      const client = await this.ensureClient();
+      const response = await client.sendTransaction(rawTx);
+
+      // Report successful RPC call
+      reportRpcStatus(true);
+      return response;
+    } catch (error) {
+      console.error('[RPC Browser] Error sending transaction:', error);
+      // Report failed RPC call
+      reportRpcStatus(false);
+      throw new Error(
+        `Failed to send transaction: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  /**
+   * Check if a transaction was accepted by the network
+   * @param txId - Base58-encoded transaction ID
+   * @returns true if accepted, false otherwise
+   */
+  async isTransactionAccepted(txId: string): Promise<boolean> {
+    try {
+      const client = await this.ensureClient();
+      const accepted = await client.transactionAccepted(txId);
+      // Report successful RPC call
+      reportRpcStatus(true);
+      return accepted;
+    } catch (error) {
+      console.error('[RPC Browser] Error checking transaction status:', error);
+      // Report failed RPC call
+      reportRpcStatus(false);
+      return false;
+    }
+  }
+
+  /**
+   * Convert proto Balance format to our Note[] interface
+   */
+  private convertBalanceToNotes(balance: any): Note[] {
+    if (!balance.notes || balance.notes.length === 0) {
+      return [];
+    }
+
+    const notes: Note[] = [];
+
+    for (const entry of balance.notes) {
+      try {
+        const note = this.convertProtoNote(entry);
+        if (note) {
+          notes.push(note);
+        }
+      } catch (error) {
+        console.error('[RPC Browser] Error converting note:', error, entry);
+      }
+    }
+
+    return notes;
+  }
+
+  /**
+   * Convert a single proto note to our Note interface
+   */
+  private convertProtoNote(balanceEntry: any): Note | null {
+    if (!balanceEntry.note) {
+      return null;
+    }
+
+    const protoNote = balanceEntry.note;
+    const name = balanceEntry.name;
+    const noteDataHash = balanceEntry.note_data_hash; // May be base58 string or undefined
+
+    // WASM client returns note_version with V1 format
+    const noteVersion = protoNote.note_version;
+    const noteData = noteVersion?.V1 || protoNote.v1;
+
+    if (!noteData) {
+      console.warn('[RPC Browser] Unknown note format:', protoNote);
+      return null;
+    }
+
+    // WASM client returns name as { first: "base58", last: "base58" } instead of bytes
+    let nameFirst: Uint8Array;
+    let nameLast: Uint8Array;
+    let nameFirstBase58: string | undefined;
+    let nameLastBase58: string | undefined;
+
+    if (name?.first && name?.last && typeof name.first === 'string') {
+      // WASM format: base58 strings
+      // Store the base58 strings for later use in transactions
+      nameFirstBase58 = name.first;
+      nameLastBase58 = name.last;
+
+      // Also decode to bytes for compatibility
+      nameFirst = base58.decode(name.first);
+      nameLast = base58.decode(name.last);
+    } else {
+      // Old format: bytes
+      const nameBytes = name?.bytes || new Uint8Array(80);
+      nameFirst = nameBytes.slice(0, 40);
+      nameLast = nameBytes.slice(40, 80);
+    }
+
+    // WASM client handles bigints properly, but we still need to convert to number for assets
+    // The WASM deserializer already handles proper bigint conversion
+    const safeToNumber = (value: any): number => {
+      if (typeof value === 'bigint') {
+        if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+          console.warn(
+            '[RPC Browser] Value exceeds MAX_SAFE_INTEGER, precision may be lost:',
+            value
+          );
+        }
+        return Number(value);
+      }
+      if (typeof value === 'string') {
+        const bigIntValue = BigInt(value);
+        if (bigIntValue > BigInt(Number.MAX_SAFE_INTEGER)) {
+          console.warn(
+            '[RPC Browser] Value exceeds MAX_SAFE_INTEGER, precision may be lost:',
+            value
+          );
+        }
+        return Number(bigIntValue);
+      }
+      return Number(value || 0);
+    };
+
+    // Extract assets - WASM format has { value: "123" }, old format is direct
+    const assetsValue = noteData.assets?.value || noteData.assets || 0;
+
+    // Extract version - WASM format has { value: "1" }, old format is direct
+    const versionValue = noteData.version?.value
+      ? parseInt(noteData.version.value)
+      : noteData.version || 1;
+
+    // Extract originPage - WASM format has { value: "123" }, old format is direct
+    const originPageValue = noteData.origin_page?.value || noteData.originPage || 0;
+
+    if (noteVersion?.Legacy || protoNote.legacy) {
+      return {
+        version: 0,
+        originPage: BigInt(originPageValue),
+        timelockMin: noteData.timelockMin ? BigInt(noteData.timelockMin) : undefined,
+        timelockMax: noteData.timelockMax ? BigInt(noteData.timelockMax) : undefined,
+        nameFirst,
+        nameLast,
+        nameFirstBase58,
+        nameLastBase58,
+        noteDataHashBase58: noteDataHash,
+        lockPubkeys: noteData.lock?.pubkeys || [],
+        lockKeysRequired: BigInt(noteData.lock?.keysRequired || 1),
+        sourceHash: noteData.source?.hash?.bytes || new Uint8Array(40),
+        sourceIsCoinbase: noteData.source?.isCoinbase || false,
+        assets: safeToNumber(assetsValue),
+        protoNote: balanceEntry.note, // Store raw protobuf for Note.fromProtobuf()
+      };
+    } else {
+      return {
+        version: versionValue,
+        originPage: BigInt(originPageValue),
+        timelockMin: undefined,
+        timelockMax: undefined,
+        nameFirst,
+        nameLast,
+        nameFirstBase58,
+        nameLastBase58,
+        noteDataHashBase58: noteDataHash,
+        lockPubkeys: [],
+        lockKeysRequired: BigInt(1),
+        sourceHash: new Uint8Array(40),
+        sourceIsCoinbase: false,
+        assets: safeToNumber(assetsValue),
+        protoNote: balanceEntry.note, // Store raw protobuf for Note.fromProtobuf()
+      };
+    }
+  }
+}
+
+/**
+ * Create a browser client instance
+ * @param endpoint - gRPC-web endpoint URL (defaults to RPC_ENDPOINT)
+ */
+export function createBrowserClient(endpoint = RPC_ENDPOINT): NockchainBrowserRPCClient {
+  return new NockchainBrowserRPCClient(endpoint);
+}