@1sat/wallet-toolbox 0.0.7 → 0.0.9

package/dist/services/client/ChaintracksClient.d.ts

@@ -1,14 +1,14 @@
 import type { ChainTracker } from "@bsv/sdk";
-import type { BlockHeader, ClientOptions } from "../types";
+import type { BaseBlockHeader, BlockHeader, Chain } from "@bsv/wallet-toolbox";
+import type { ClientOptions } from "../types";
 import { BaseClient } from "./BaseClient";
 /**
  * Client for /1sat/chaintracks/* routes.
- * Provides block header data and implements ChainTracker interface.
+ * Implements ChaintracksClientApi interface from @bsv/wallet-toolbox.
  *
  * Routes:
  * - GET /tip - Get chain tip
  * - GET /tip/stream - SSE stream of new blocks
- * - GET /height - Get current height
  * - GET /network - Get network type
  * - GET /headers?height=N&count=M - Get raw header bytes
  * - GET /header/height/:height - Get header by height
@@ -17,6 +17,9 @@ import { BaseClient } from "./BaseClient";
 export declare class ChaintracksClient extends BaseClient implements ChainTracker {
     private eventSource;
     private subscribers;
+    private cachedTip;
+    private cachedTipTime;
+    private static readonly TIP_CACHE_TTL_MS;
     constructor(baseUrl: string, options?: ClientOptions);
     /**
      * Get current blockchain height (ChainTracker interface)
@@ -27,25 +30,64 @@ export declare class ChaintracksClient extends BaseClient implements ChainTracke
      */
     isValidRootForHeight(root: string, height: number): Promise<boolean>;
     /**
-     * Get the network type (main or test)
+     * Get the blockchain network (main or test)
      */
-    getNetwork(): Promise<string>;
+    getChain(): Promise<Chain>;
     /**
-     * Get the current chain tip
+     * Get service info - synthetic for remote client
      */
-    getTip(): Promise<BlockHeader>;
+    getInfo(): Promise<{
+        chain: Chain;
+        heightBulk: number;
+        heightLive: number;
+        storage: string;
+        bulkIngestors: string[];
+        liveIngestors: string[];
+        packages: {
+            name: string;
+            version: string;
+        }[];
+    }>;
     /**
-     * Get block header by height
+     * Get current chain height
      */
-    getHeaderByHeight(height: number): Promise<BlockHeader>;
+    getPresentHeight(): Promise<number>;
     /**
-     * Get block header by hash
+     * Get headers as serialized 80-byte hex string
+     */
+    getHeaders(height: number, count: number): Promise<string>;
+    /**
+     * Get the current chain tip header (cached for 30 seconds)
+     */
+    findChainTipHeader(): Promise<BlockHeader>;
+    /**
+     * Get the current chain tip hash
      */
-    getHeaderByHash(hash: string): Promise<BlockHeader>;
+    findChainTipHash(): Promise<string>;
     /**
-     * Get multiple headers as parsed BlockHeader objects
+     * Get block header by height
+     */
+    findHeaderForHeight(height: number): Promise<BlockHeader | undefined>;
+    /**
+     * Get block header by hash
      */
-    getHeaders(height: number, count: number): Promise<BlockHeader[]>;
+    findHeaderForBlockHash(hash: string): Promise<BlockHeader | undefined>;
+    /** No-op: Remote server tracks the chain */
+    addHeader(_header: BaseBlockHeader): Promise<void>;
+    /** No-op: Client is always ready */
+    startListening(): Promise<void>;
+    /** No-op: Resolves immediately */
+    listening(): Promise<void>;
+    /** Always true for remote client */
+    isListening(): Promise<boolean>;
+    /** Always true for remote client */
+    isSynchronized(): Promise<boolean>;
+    /** Not implemented for remote client */
+    subscribeReorgs(_listener: (depth: number, oldTip: BlockHeader, newTip: BlockHeader, deactivatedHeaders?: BlockHeader[]) => void): Promise<string>;
+    /** Unsubscribe from events */
+    unsubscribe(_subscriptionId: string): Promise<boolean>;
+    /** Subscribe to new header events */
+    subscribeHeaders(listener: (header: BlockHeader) => void): Promise<string>;
     /**
      * Get raw header bytes for one or more headers
      */

package/dist/services/client/ChaintracksClient.js

@@ -36,22 +36,29 @@ async function doubleSha256(data) {
  */
 async function parseHeader(data, height) {
     const version = readUint32LE(data, 0);
-    const prevHash = toHexLE(data.slice(4, 36));
+    const previousHash = toHexLE(data.slice(4, 36));
     const merkleRoot = toHexLE(data.slice(36, 68));
     const time = readUint32LE(data, 68);
     const bits = readUint32LE(data, 72);
     const nonce = readUint32LE(data, 76);
     const hash = toHexLE(await doubleSha256(data));
-    return { height, hash, version, prevHash, merkleRoot, time, bits, nonce };
+    return { height, hash, version, previousHash, merkleRoot, time, bits, nonce };
+}
+/**
+ * Convert bytes to hex string (big-endian / natural order)
+ */
+function toHex(data) {
+    return Array.from(data)
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("");
 }
 /**
  * Client for /1sat/chaintracks/* routes.
- * Provides block header data and implements ChainTracker interface.
+ * Implements ChaintracksClientApi interface from @bsv/wallet-toolbox.
  *
  * Routes:
  * - GET /tip - Get chain tip
  * - GET /tip/stream - SSE stream of new blocks
- * - GET /height - Get current height
  * - GET /network - Get network type
  * - GET /headers?height=N&count=M - Get raw header bytes
  * - GET /header/height/:height - Get header by height
@@ -60,6 +67,10 @@ async function parseHeader(data, height) {
 export class ChaintracksClient extends BaseClient {
     eventSource = null;
     subscribers = new Set();
+    // Chain tip cache (30 second TTL)
+    cachedTip = null;
+    cachedTipTime = 0;
+    static TIP_CACHE_TTL_MS = 30_000;
     constructor(baseUrl, options = {}) {
         super(`${baseUrl}/1sat/chaintracks`, options);
     }
@@ -67,7 +78,7 @@ export class ChaintracksClient extends BaseClient {
      * Get current blockchain height (ChainTracker interface)
      */
     async currentHeight() {
-        const tip = await this.getTip();
+        const tip = await this.findChainTipHeader();
         return tip.height;
     }
     /**
@@ -75,9 +86,8 @@ export class ChaintracksClient extends BaseClient {
      */
     async isValidRootForHeight(root, height) {
         try {
-            const header = await this.getHeaderByHeight(height);
-            const isValid = header.merkleRoot === root;
-            return isValid;
+            const header = await this.findHeaderForHeight(height);
+            return header?.merkleRoot === root;
         }
         catch (e) {
             console.error(`isValidRootForHeight(${height}) failed:`, e);
@@ -85,43 +95,128 @@ export class ChaintracksClient extends BaseClient {
         }
     }
     /**
-     * Get the network type (main or test)
+     * Get the blockchain network (main or test)
      */
-    async getNetwork() {
+    async getChain() {
         const data = await this.request("/network");
         return data.network;
     }
     /**
-     * Get the current chain tip
+     * Get service info - synthetic for remote client
      */
-    async getTip() {
-        return this.request("/tip");
+    async getInfo() {
+        const tip = await this.findChainTipHeader();
+        const chain = await this.getChain();
+        return {
+            chain,
+            heightBulk: tip.height,
+            heightLive: tip.height,
+            storage: "remote",
+            bulkIngestors: [],
+            liveIngestors: [],
+            packages: [],
+        };
     }
     /**
-     * Get block header by height
+     * Get current chain height
      */
-    async getHeaderByHeight(height) {
-        return this.request(`/header/height/${height}`);
+    async getPresentHeight() {
+        return this.currentHeight();
     }
     /**
-     * Get block header by hash
+     * Get headers as serialized 80-byte hex string
      */
-    async getHeaderByHash(hash) {
-        return this.request(`/header/hash/${hash}`);
+    async getHeaders(height, count) {
+        const data = await this.requestBinary(`/headers?height=${height}&count=${count}`);
+        return toHex(data);
     }
     /**
-     * Get multiple headers as parsed BlockHeader objects
+     * Get the current chain tip header (cached for 30 seconds)
      */
-    async getHeaders(height, count) {
-        const data = await this.requestBinary(`/headers?height=${height}&count=${count}`);
-        if (data.length % 80 !== 0) {
-            throw new Error(`Invalid response length: ${data.length} bytes`);
+    async findChainTipHeader() {
+        const now = Date.now();
+        if (this.cachedTip && now - this.cachedTipTime < ChaintracksClient.TIP_CACHE_TTL_MS) {
+            return this.cachedTip;
         }
-        const headers = [];
-        for (let i = 0; i < data.length; i += 80) {
-            headers.push(await parseHeader(data.slice(i, i + 80), height + i / 80));
+        const header = await this.request("/tip");
+        console.log("[ChaintracksClient] findChainTipHeader:", header.height, header.hash);
+        this.cachedTip = header;
+        this.cachedTipTime = now;
+        return header;
+    }
+    /**
+     * Get the current chain tip hash
+     */
+    async findChainTipHash() {
+        const tip = await this.findChainTipHeader();
+        return tip.hash;
+    }
+    /**
+     * Get block header by height
+     */
+    async findHeaderForHeight(height) {
+        try {
+            return await this.request(`/header/height/${height}`);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Get block header by hash
+     */
+    async findHeaderForBlockHash(hash) {
+        try {
+            return await this.request(`/header/hash/${hash}`);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** No-op: Remote server tracks the chain */
+    async addHeader(_header) { }
+    /** No-op: Client is always ready */
+    async startListening() { }
+    /** No-op: Resolves immediately */
+    async listening() { }
+    /** Always true for remote client */
+    async isListening() {
+        return true;
+    }
+    /** Always true for remote client */
+    async isSynchronized() {
+        return true;
+    }
+    /** Not implemented for remote client */
+    async subscribeReorgs(_listener) {
+        throw new Error("Method not implemented.");
+    }
+    /** Unsubscribe from events */
+    async unsubscribe(_subscriptionId) {
+        return false;
+    }
+    /** Subscribe to new header events */
+    async subscribeHeaders(listener) {
+        this.subscribers.add(listener);
+        if (!this.eventSource) {
+            this.eventSource = new EventSource(`${this.baseUrl}/tip/stream`);
+            this.eventSource.onmessage = (event) => {
+                try {
+                    const header = JSON.parse(event.data);
+                    for (const cb of this.subscribers) {
+                        cb(header);
+                    }
+                }
+                catch {
+                    // Ignore parse errors
+                }
+            };
+            this.eventSource.onerror = () => {
+                this.eventSource?.close();
+                this.eventSource = null;
+            };
         }
-        return headers;
+        return "subscription";
     }
     /**
      * Get raw header bytes for one or more headers

package/dist/services/client/OrdfsClient.d.ts

@@ -4,8 +4,8 @@ import { BaseClient } from "./BaseClient";
  * Client for ordfs routes.
  * Provides inscription content and metadata.
  *
- * Content is served from /1sat/content (e.g., https://api.1sat.app/1sat/content/:outpoint)
- * API routes use /1sat/ordfs (e.g., https://api.1sat.app/1sat/ordfs/metadata/:outpoint)
+ * Content is served from /content (e.g., https://1sat.shruggr.cloud/content/:outpoint)
+ * API routes use /1sat/ordfs (e.g., https://1sat.shruggr.cloud/1sat/ordfs/metadata/:outpoint)
  */
 export declare class OrdfsClient extends BaseClient {
     private readonly contentBaseUrl;

package/dist/services/client/OrdfsClient.js

@@ -3,14 +3,15 @@ import { BaseClient } from "./BaseClient";
  * Client for ordfs routes.
  * Provides inscription content and metadata.
  *
- * Content is served from /1sat/content (e.g., https://api.1sat.app/1sat/content/:outpoint)
- * API routes use /1sat/ordfs (e.g., https://api.1sat.app/1sat/ordfs/metadata/:outpoint)
+ * Content is served from /content (e.g., https://1sat.shruggr.cloud/content/:outpoint)
+ * API routes use /1sat/ordfs (e.g., https://1sat.shruggr.cloud/1sat/ordfs/metadata/:outpoint)
  */
 export class OrdfsClient extends BaseClient {
     contentBaseUrl;
     constructor(baseUrl, options = {}) {
         super(`${baseUrl}/1sat/ordfs`, options);
-        this.contentBaseUrl = `${baseUrl.replace(/\/$/, "")}/1sat/content`;
+        // Content is at root /content, not under /1sat/
+        this.contentBaseUrl = `${baseUrl.replace(/\/$/, "")}/content`;
     }
     /**
      * Get metadata for an inscription

package/dist/services/client/TxoClient.js

@@ -21,6 +21,9 @@ export class TxoClient extends BaseClient {
     async get(outpoint, opts) {
         const qs = this.buildQueryString({
             tags: opts?.tags,
+            sats: opts?.sats,
+            spend: opts?.spend,
+            block: opts?.block,
         });
         return this.request(`/${outpoint}${qs}`);
     }
@@ -30,6 +33,9 @@ export class TxoClient extends BaseClient {
     async getBatch(outpoints, opts) {
         const qs = this.buildQueryString({
             tags: opts?.tags,
+            sats: opts?.sats,
+            spend: opts?.spend,
+            block: opts?.block,
         });
         return this.request(`/outpoints${qs}`, {
             method: "POST",
@@ -61,6 +67,9 @@ export class TxoClient extends BaseClient {
     async getByTxid(txid, opts) {
         const qs = this.buildQueryString({
             tags: opts?.tags,
+            sats: opts?.sats,
+            spend: opts?.spend,
+            block: opts?.block,
         });
         return this.request(`/tx/${txid}${qs}`);
     }

package/dist/sync/AddressManager.d.ts

@@ -0,0 +1,85 @@
+/**
+ * AddressManager - Manages yours receive addresses using BRC-29 derivation format.
+ *
+ * Yours receive addresses are fixed, public addresses that users share publicly.
+ * They are derived deterministically from the identity key using:
+ * - derivationPrefix: "yours receive" (fixed)
+ * - derivationSuffix: "0", "1", "2", ... (sequential counter)
+ * - senderIdentityKey: our own identity public key (self-referential derivation)
+ *
+ * This allows:
+ * 1. Deterministic regeneration on wallet restore
+ * 2. Syncing external payments to these addresses
+ * 3. Auto-signing via BRC-29/ScriptTemplateBRC29 (wallet knows the derivation info)
+ *
+ * Address derivation is done externally (in yours-wallet) and passed to this class.
+ */
+import { type WalletProtocol } from "@bsv/sdk";
+/** Fixed prefix for yours receive addresses */
+export declare const YOURS_PREFIX = "yours";
+/** BRC-29 protocol ID - used by wallet-toolbox for key derivation and signing */
+export declare const BRC29_PROTOCOL_ID: WalletProtocol;
+/**
+ * Derivation info for a yours receive address.
+ * This is what's needed for internalizeAction's paymentRemittance.
+ */
+export interface AddressDerivation {
+    /** The Bitcoin address (base58check) */
+    address: string;
+    /** The key index (0, 1, 2, etc.) for internal lookups */
+    index: number;
+    /** Base64-encoded derivation prefix (e.g., base64("yours receive")) */
+    derivationPrefix: string;
+    /** Base64-encoded derivation suffix (e.g., base64("0"), base64("1"), etc.) */
+    derivationSuffix: string;
+    /** Our own identity public key (self-referential) */
+    senderIdentityKey: string;
+    /** The public key for this address */
+    publicKey: string;
+}
+/**
+ * AddressManager manages yours receive addresses.
+ * Accepts pre-derived addresses - derivation is done externally.
+ */
+export declare class AddressManager {
+    private addressMap;
+    private maxKeyIndex;
+    /**
+     * @param derivations - Pre-derived address derivations
+     */
+    constructor(derivations: AddressDerivation[]);
+    /**
+     * Add a new address derivation.
+     */
+    addAddress(derivation: AddressDerivation): void;
+    /**
+     * Get the current max key index.
+     * This should be persisted to chrome.storage.
+     */
+    getMaxKeyIndex(): number;
+    /**
+     * Get all known addresses.
+     */
+    getAddresses(): string[];
+    /**
+     * Get derivation info for an address, or undefined if not ours.
+     */
+    getDerivation(address: string): AddressDerivation | undefined;
+    /**
+     * Check if an address belongs to this wallet.
+     */
+    isOurAddress(address: string): boolean;
+    /**
+     * Get the primary receive address (index 0).
+     */
+    getPrimaryAddress(): string | undefined;
+    /**
+     * Get address at a specific index.
+     */
+    getAddressAtIndex(index: number): AddressDerivation | undefined;
+    /**
+     * Build the locking script for an address at a specific index.
+     * Useful for verifying outputs match expected scripts.
+     */
+    getLockingScriptAtIndex(index: number): string | undefined;
+}

package/dist/sync/AddressManager.js

@@ -0,0 +1,107 @@
+/**
+ * AddressManager - Manages yours receive addresses using BRC-29 derivation format.
+ *
+ * Yours receive addresses are fixed, public addresses that users share publicly.
+ * They are derived deterministically from the identity key using:
+ * - derivationPrefix: "yours receive" (fixed)
+ * - derivationSuffix: "0", "1", "2", ... (sequential counter)
+ * - senderIdentityKey: our own identity public key (self-referential derivation)
+ *
+ * This allows:
+ * 1. Deterministic regeneration on wallet restore
+ * 2. Syncing external payments to these addresses
+ * 3. Auto-signing via BRC-29/ScriptTemplateBRC29 (wallet knows the derivation info)
+ *
+ * Address derivation is done externally (in yours-wallet) and passed to this class.
+ */
+import { P2PKH } from "@bsv/sdk";
+/** Fixed prefix for yours receive addresses */
+export const YOURS_PREFIX = 'yours';
+/** BRC-29 protocol ID - used by wallet-toolbox for key derivation and signing */
+export const BRC29_PROTOCOL_ID = [2, "3241645161d8"];
+/**
+ * AddressManager manages yours receive addresses.
+ * Accepts pre-derived addresses - derivation is done externally.
+ */
+export class AddressManager {
+    addressMap = new Map();
+    maxKeyIndex = -1;
+    /**
+     * @param derivations - Pre-derived address derivations
+     */
+    constructor(derivations) {
+        for (const derivation of derivations) {
+            this.addressMap.set(derivation.address, derivation);
+            if (derivation.index > this.maxKeyIndex) {
+                this.maxKeyIndex = derivation.index;
+            }
+        }
+    }
+    /**
+     * Add a new address derivation.
+     */
+    addAddress(derivation) {
+        this.addressMap.set(derivation.address, derivation);
+        if (derivation.index > this.maxKeyIndex) {
+            this.maxKeyIndex = derivation.index;
+        }
+    }
+    /**
+     * Get the current max key index.
+     * This should be persisted to chrome.storage.
+     */
+    getMaxKeyIndex() {
+        return this.maxKeyIndex;
+    }
+    /**
+     * Get all known addresses.
+     */
+    getAddresses() {
+        return Array.from(this.addressMap.keys());
+    }
+    /**
+     * Get derivation info for an address, or undefined if not ours.
+     */
+    getDerivation(address) {
+        return this.addressMap.get(address);
+    }
+    /**
+     * Check if an address belongs to this wallet.
+     */
+    isOurAddress(address) {
+        return this.addressMap.has(address);
+    }
+    /**
+     * Get the primary receive address (index 0).
+     */
+    getPrimaryAddress() {
+        for (const derivation of this.addressMap.values()) {
+            if (derivation.index === 0) {
+                return derivation.address;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Get address at a specific index.
+     */
+    getAddressAtIndex(index) {
+        for (const derivation of this.addressMap.values()) {
+            if (derivation.index === index) {
+                return derivation;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Build the locking script for an address at a specific index.
+     * Useful for verifying outputs match expected scripts.
+     */
+    getLockingScriptAtIndex(index) {
+        const derivation = this.getAddressAtIndex(index);
+        if (!derivation)
+            return undefined;
+        const p2pkh = new P2PKH();
+        return p2pkh.lock(derivation.address).toHex();
+    }
+}