@1sat/wallet-toolbox 0.0.1 → 0.0.3

package/dist/indexers/Bsv21Indexer.d.ts

@@ -1,5 +1,5 @@
-import { Indexer, type IndexData, type IndexSummary, type ParseContext } from "./types";
 import type { OneSatServices } from "../services/OneSatServices";
+import { type IndexSummary, Indexer, type ParseContext, type ParseResult, type Txo } from "./types";
 export interface Bsv21 {
     id: string;
     op: string;
@@ -18,7 +18,7 @@ export interface Bsv21 {
  * Data structure: Bsv21 with id, op, amt, dec, status, etc.
  *
  * Basket: 'bsv21'
- * Events: address, id, status
+ * Events: id, id:status, bsv21:amt
  */
 export declare class Bsv21Indexer extends Indexer {
     owners: Set<string>;
@@ -26,9 +26,9 @@ export declare class Bsv21Indexer extends Indexer {
     services: OneSatServices;
     tag: string;
     name: string;
-    constructor(owners: Set<string> | undefined, network: "mainnet" | "testnet" | undefined, services: OneSatServices);
-    parse(ctx: ParseContext, vout: number, _isBroadcasted: boolean): Promise<IndexData | undefined>;
-    summerize(ctx: ParseContext): Promise<IndexSummary | undefined>;
+    constructor(owners: Set<string>, network: "mainnet" | "testnet", services: OneSatServices);
+    parse(txo: Txo): Promise<ParseResult | undefined>;
+    summarize(ctx: ParseContext): Promise<IndexSummary | undefined>;
     serialize(bsv21: Bsv21): string;
     deserialize(str: string): Bsv21;
 }

package/dist/indexers/CosignIndexer.d.ts

@@ -1,5 +1,5 @@
-import { Indexer, type IndexData, type ParseContext } from "./types";
-export interface Cosign {
+import { Indexer, type ParseResult, type Txo } from "./types";
+export interface CosignData {
     address: string;
     cosigner: string;
 }
@@ -9,5 +9,5 @@ export declare class CosignIndexer extends Indexer {
     tag: string;
     name: string;
     constructor(owners?: Set<string>, network?: "mainnet" | "testnet");
-    parse(ctx: ParseContext, vout: number): Promise<IndexData | undefined>;
+    parse(txo: Txo): Promise<ParseResult | undefined>;
 }

package/dist/indexers/FundIndexer.d.ts

@@ -1,4 +1,4 @@
-import { Indexer, type IndexData, type IndexSummary, type ParseContext } from "./types";
+import { type IndexSummary, Indexer, type ParseContext, type ParseResult, type Txo } from "./types";
 /**
  * FundIndexer identifies P2PKH outputs to owned addresses.
  * These are standard "funding" UTXOs that can be spent normally.
@@ -14,6 +14,6 @@ export declare class FundIndexer extends Indexer {
     tag: string;
     name: string;
     constructor(owners?: Set<string>, network?: "mainnet" | "testnet");
-    parse(ctx: ParseContext, vout: number): Promise<IndexData | undefined>;
-    summerize(ctx: ParseContext): Promise<IndexSummary | undefined>;
+    parse(txo: Txo): Promise<ParseResult | undefined>;
+    summarize(ctx: ParseContext): Promise<IndexSummary | undefined>;
 }

package/dist/indexers/InscriptionIndexer.d.ts

@@ -1,4 +1,4 @@
-import { Indexer, type IndexData, type ParseContext } from "./types";
+import { type IndexSummary, Indexer, type ParseContext, type ParseResult, type Txo } from "./types";
 export interface File {
     hash: string;
     size: number;
@@ -27,5 +27,6 @@ export declare class InscriptionIndexer extends Indexer {
     tag: string;
     name: string;
     constructor(owners?: Set<string>, network?: "mainnet" | "testnet");
-    parse(ctx: ParseContext, vout: number): Promise<IndexData | undefined>;
+    parse(txo: Txo): Promise<ParseResult | undefined>;
+    summarize(ctx: ParseContext): Promise<IndexSummary | undefined>;
 }

package/dist/indexers/LockIndexer.d.ts

@@ -1,10 +1,10 @@
-import { Indexer, type IndexData, type IndexSummary, type ParseContext } from "./types";
+import { type IndexSummary, Indexer, type ParseContext, type ParseResult, type Txo } from "./types";
 export interface LockData {
     until: number;
 }
 export declare class LockIndexer extends Indexer {
     tag: string;
     name: string;
-    parse(ctx: ParseContext, vout: number): Promise<IndexData | undefined>;
-    summerize(ctx: ParseContext): Promise<IndexSummary | undefined>;
+    parse(txo: Txo): Promise<ParseResult | undefined>;
+    summarize(ctx: ParseContext): Promise<IndexSummary | undefined>;
 }

package/dist/indexers/MapIndexer.d.ts

@@ -1,13 +1,12 @@
 import { Script } from "@bsv/sdk";
-import { Indexer, type IndexData, type ParseContext } from "./types";
-export declare const MAP_PROTO = "1PuQa7K62MiKCtssSLKy1kh56WWU7MtUR5";
+import { Indexer, type ParseResult, type Txo } from "./types";
 export declare class MapIndexer extends Indexer {
     owners: Set<string>;
     network: "mainnet" | "testnet";
     tag: string;
     name: string;
     constructor(owners?: Set<string>, network?: "mainnet" | "testnet");
-    parse(ctx: ParseContext, vout: number): Promise<IndexData | undefined>;
+    parse(txo: Txo): Promise<ParseResult | undefined>;
     static parseMap(script: Script, mapPos: number): {
         [key: string]: unknown;
     } | undefined;

package/dist/indexers/OpNSIndexer.d.ts

@@ -1,9 +1,9 @@
-import { Indexer, type IndexData, type ParseContext } from "./types";
+import { Indexer, type ParseResult, type Txo } from "./types";
 export declare class OpNSIndexer extends Indexer {
     owners: Set<string>;
     network: "mainnet" | "testnet";
     tag: string;
     name: string;
     constructor(owners?: Set<string>, network?: "mainnet" | "testnet");
-    parse(ctx: ParseContext, vout: number): Promise<IndexData | undefined>;
+    parse(txo: Txo): Promise<ParseResult | undefined>;
 }

package/dist/indexers/OrdLockIndexer.d.ts

@@ -1,4 +1,4 @@
-import { Indexer, type IndexData, type ParseContext, type IndexSummary } from "./types";
+import { type IndexSummary, Indexer, type ParseContext, type ParseResult, type Txo } from "./types";
 export declare class Listing {
     payout: number[];
     price: bigint;
@@ -10,8 +10,8 @@ export declare class OrdLockIndexer extends Indexer {
     tag: string;
     name: string;
     constructor(owners?: Set<string>, network?: "mainnet" | "testnet");
-    parse(ctx: ParseContext, vout: number): Promise<IndexData | undefined>;
-    summerize(ctx: ParseContext): Promise<IndexSummary | undefined>;
+    parse(txo: Txo): Promise<ParseResult | undefined>;
+    summarize(ctx: ParseContext): Promise<IndexSummary | undefined>;
     serialize(listing: Listing): string;
     deserialize(str: string): Listing;
 }

package/dist/indexers/OriginIndexer.d.ts

@@ -1,7 +1,7 @@
-import { Indexer, type IndexData, type ParseContext, type IndexSummary } from "./types";
+import type { OneSatServices } from "../services/OneSatServices";
 import type { Inscription } from "./InscriptionIndexer";
 import type { Sigma } from "./SigmaIndexer";
-import type { OneSatServices } from "../services/OneSatServices";
+import { type IndexSummary, Indexer, type ParseContext, type ParseResult, type Txo } from "./types";
 export interface Origin {
     outpoint?: string;
     nonce?: number;
@@ -17,7 +17,21 @@ export declare class OriginIndexer extends Indexer {
     private services;
     tag: string;
     name: string;
-    constructor(owners: Set<string> | undefined, network: "mainnet" | "testnet" | undefined, services: OneSatServices);
-    parse(ctx: ParseContext, vout: number): Promise<IndexData | undefined>;
-    summerize(ctx: ParseContext): Promise<IndexSummary | undefined>;
+    constructor(owners: Set<string>, network: "mainnet" | "testnet", services: OneSatServices);
+    /**
+     * Parse identifies 1-sat ordinal outputs and extracts basic data.
+     * Origin tracking (determining if transfer vs new) is done in summarize()
+     * since it requires cross-output and cross-input context.
+     */
+    parse(txo: Txo): Promise<ParseResult | undefined>;
+    /**
+     * Summarize determines origin tracking (transfer vs new origin) and
+     * fetches metadata from OrdFS for transfers.
+     */
+    summarize(ctx: ParseContext): Promise<IndexSummary | undefined>;
+    /**
+     * Resolve origins for all 1-sat outputs in the transaction.
+     * This determines whether each is a new origin or a transfer.
+     */
+    private resolveOrigins;
 }

package/dist/indexers/SigmaIndexer.d.ts

@@ -1,4 +1,4 @@
-import { Indexer, type IndexData, type ParseContext } from "./types";
+import { Indexer, type ParseContext, type ParseResult, type Txo } from "./types";
 export interface Sigma {
     algorithm: string;
     address: string;
@@ -12,5 +12,17 @@ export declare class SigmaIndexer extends Indexer {
     tag: string;
     name: string;
     constructor(owners?: Set<string>, network?: "mainnet" | "testnet");
-    parse(ctx: ParseContext, vout: number): Promise<IndexData | undefined>;
+    /**
+     * Parse extracts raw sigma protocol data without validation.
+     * Validation requires ctx.spends and is done in summarize().
+     */
+    parse(txo: Txo): Promise<ParseResult | undefined>;
+    /**
+     * Validate all sigma signatures against ctx.spends.
+     */
+    summarize(ctx: ParseContext, _isBroadcasted: boolean): Promise<undefined>;
+    /**
+     * Find the data position for a sigma in the script (position before the pipe separator).
+     */
+    private findSigmaDataPos;
 }

package/dist/indexers/index.d.ts

@@ -1,15 +1,14 @@
-export { Indexer, type IndexData, type IndexSummary, type ParseContext, type Txo } from "./types";
-export type { Bsv21TokenData, Bsv21OutputData, Bsv21TransactionData } from "./types";
+export { Indexer, type IndexData, type IndexSummary, type ParseContext, type ParseResult, type Txo, } from "./types";
+export type { Bsv21TokenData, Bsv21OutputData, Bsv21TransactionData, } from "./types";
 export { Outpoint } from "./Outpoint";
 export { parseAddress } from "./parseAddress";
 export { FundIndexer } from "./FundIndexer";
 export { LockIndexer } from "./LockIndexer";
-export { InscriptionIndexer, type File, type Inscription } from "./InscriptionIndexer";
+export { InscriptionIndexer, type File, type Inscription, } from "./InscriptionIndexer";
 export { SigmaIndexer, type Sigma } from "./SigmaIndexer";
-export { MapIndexer, MAP_PROTO } from "./MapIndexer";
+export { MapIndexer } from "./MapIndexer";
 export { OriginIndexer, type Origin } from "./OriginIndexer";
 export { Bsv21Indexer, deriveFundAddress, type Bsv21 } from "./Bsv21Indexer";
 export { OrdLockIndexer, Listing } from "./OrdLockIndexer";
 export { OpNSIndexer } from "./OpNSIndexer";
-export { CosignIndexer, type Cosign } from "./CosignIndexer";
-export { TransactionParser, type ParsedOutput, type ParseResult } from "./TransactionParser";
+export { CosignIndexer, type CosignData } from "./CosignIndexer";

package/dist/indexers/types.d.ts

@@ -1,4 +1,4 @@
-import type { Transaction } from "@bsv/sdk";
+import type { Transaction, TransactionOutput } from "@bsv/sdk";
 import type { Outpoint } from "./Outpoint";
 /**
  * BSV21 token data structure from overlay API
@@ -42,6 +42,8 @@ export interface Bsv21TransactionData {
 export interface IndexData {
     data: unknown;
     tags: string[];
+    /** Optional text content (e.g., from text inscriptions). */
+    content?: string;
 }
 /**
  * IndexSummary contains transaction-level summary information
@@ -53,17 +55,27 @@ export interface IndexSummary {
     data?: unknown;
 }
 /**
- * Minimal transaction output structure used during parsing
+ * Result from Indexer.parse() method
+ */
+export interface ParseResult {
+    data: unknown;
+    tags: string[];
+    owner?: string;
+    basket?: string;
+    /** Optional text content (e.g., from text inscriptions). Truncated to 1000 chars when stored. */
+    content?: string;
+}
+/**
+ * Transaction output structure used during parsing
  */
 export interface Txo {
-    satoshis: bigint;
-    script: number[];
+    output: TransactionOutput;
+    outpoint: Outpoint;
     owner?: string;
     basket?: string;
     data: {
         [tag: string]: IndexData;
     };
-    outpoint: Outpoint;
 }
 /**
  * Minimal context structure for indexer parsing
@@ -88,12 +100,14 @@ export declare abstract class Indexer {
     abstract name: string;
     constructor(owners?: Set<string>, network?: "mainnet" | "testnet");
     /**
-     * Parses an output and returns the index data if it is relevant to this indexer.
-     * If the output is not relevant, it returns undefined.
+     * Parses a single output in isolation and returns the parse result if relevant.
+     * Cannot access other outputs or inputs - only the single Txo.
+     * Cross-output/cross-input logic belongs in summarize().
      */
-    abstract parse(ctx: ParseContext, vout: number, isBroadcasted: boolean): Promise<IndexData | undefined>;
+    abstract parse(txo: Txo): Promise<ParseResult | undefined>;
     /**
-     * Evaluates the index data for the entire transaction and returns a summary.
+     * Post-parse phase with full transaction context.
+     * Used for cross-output/cross-input validation and transaction-level summarization.
      */
-    summerize(_ctx: ParseContext, _isBroadcasted: boolean): Promise<IndexSummary | undefined>;
+    summarize(_ctx: ParseContext, _isBroadcasted: boolean): Promise<IndexSummary | undefined>;
 }

package/dist/services/OneSatServices.d.ts

@@ -1,83 +1,61 @@
-import { Beef, ChainTracker, Transaction } from "@bsv/sdk";
+import { Beef, Transaction } from "@bsv/sdk";
 import type { WalletStorageManager } from "@bsv/wallet-toolbox/mobile";
-import type { WalletServices, GetRawTxResult, GetMerklePathResult, PostBeefResult, GetUtxoStatusResult, GetStatusForTxidsResult, GetScriptHashHistoryResult, BlockHeader, GetUtxoStatusOutputFormat, ServicesCallHistory } from "@bsv/wallet-toolbox/mobile/out/src/sdk/WalletServices.interfaces";
+import type { BlockHeader, GetMerklePathResult, GetRawTxResult, GetScriptHashHistoryResult, GetStatusForTxidsResult, GetUtxoStatusOutputFormat, GetUtxoStatusResult, PostBeefResult, ServicesCallHistory, WalletServices } from "@bsv/wallet-toolbox/mobile/out/src/sdk/WalletServices.interfaces";
 import type { Chain } from "@bsv/wallet-toolbox/mobile/out/src/sdk/types";
 import type { TableOutput } from "@bsv/wallet-toolbox/mobile/out/src/storage/schema/tables/TableOutput";
-import type { Bsv21TransactionData } from "../indexers/types";
-/**
- * OrdFS metadata response structure
- */
-export interface OrdfsMetadata {
-    outpoint: string;
-    origin?: string;
-    sequence: number;
-    contentType: string;
-    contentLength: number;
-    parent?: string;
-    map?: {
-        [key: string]: unknown;
-    };
-}
-/**
- * BSV21 token details from the overlay
- */
-export interface Bsv21TokenDetails {
-    id: string;
-    txid: string;
-    vout: number;
-    op: string;
-    amt: string;
-    sym?: string;
-    dec: number;
-    icon?: string;
-}
+import { ArcadeClient, BeefClient, Bsv21Client, ChaintracksClient, OrdfsClient, OwnerClient, TxoClient } from "./client";
+import type { Capability, SyncOutput } from "./types";
+export type { SyncOutput };
 /**
  * WalletServices implementation for 1Sat ecosystem.
  *
- * Data sources:
- * - ordfs-server - Block headers, merkle proofs, raw transactions
- * - OneSat API - Transaction broadcasting
+ * Provides access to 1Sat API clients and implements the WalletServices
+ * interface required by wallet-toolbox.
+ *
+ * API Routes:
+ * - /api/chaintracks/* - Block headers and chain tracking
+ * - /api/beef/* - Raw transactions and proofs
+ * - /api/arcade/* - Transaction broadcasting
+ * - /api/bsv21/* - BSV21 token data
+ * - /api/txo/* - Transaction outputs
+ * - /api/owner/* - Address queries and sync
+ * - /api/ordfs/* - Content/inscription serving
  */
 export declare class OneSatServices implements WalletServices {
     chain: Chain;
-    private ordfsBaseUrl;
-    readonly onesatBaseUrl: string;
-    private bsv21TokenCache;
-    private chainTracker;
+    readonly baseUrl: string;
     private storage?;
-    constructor(chain: Chain, ordfsUrl?: string, onesatUrl?: string, storage?: WalletStorageManager);
-    getChainTracker(): Promise<ChainTracker>;
+    readonly chaintracks: ChaintracksClient;
+    readonly beef: BeefClient;
+    readonly arcade: ArcadeClient;
+    readonly txo: TxoClient;
+    readonly owner: OwnerClient;
+    readonly ordfs: OrdfsClient;
+    readonly bsv21: Bsv21Client;
+    constructor(chain: Chain, baseUrl?: string, storage?: WalletStorageManager);
+    /**
+     * Get list of enabled capabilities from the server
+     */
+    getCapabilities(): Promise<Capability[]>;
+    /**
+     * Close all client connections
+     */
+    close(): void;
+    getRawTx(txid: string, _useNext?: boolean): Promise<GetRawTxResult>;
+    getChainTracker(): Promise<ChaintracksClient>;
     getHeaderForHeight(height: number): Promise<number[]>;
     getHeight(): Promise<number>;
-    getBsvExchangeRate(): Promise<number>;
-    getFiatExchangeRate(_currency: "USD" | "GBP" | "EUR", _base?: "USD" | "GBP" | "EUR"): Promise<number>;
-    getRawTx(txid: string, _useNext?: boolean): Promise<GetRawTxResult>;
     getMerklePath(txid: string, _useNext?: boolean): Promise<GetMerklePathResult>;
     postBeef(beef: Beef, txids: string[]): Promise<PostBeefResult[]>;
+    getBeefForTxid(txid: string): Promise<Beef>;
     hashOutputScript(script: string): string;
+    getServicesCallHistory(_reset?: boolean): ServicesCallHistory;
+    getBsvExchangeRate(): Promise<number>;
+    getFiatExchangeRate(_currency: "USD" | "GBP" | "EUR", _base?: "USD" | "GBP" | "EUR"): Promise<number>;
     getStatusForTxids(_txids: string[], _useNext?: boolean): Promise<GetStatusForTxidsResult>;
     isUtxo(_output: TableOutput): Promise<boolean>;
     getUtxoStatus(_output: string, _outputFormat?: GetUtxoStatusOutputFormat, _outpoint?: string, _useNext?: boolean): Promise<GetUtxoStatusResult>;
     getScriptHashHistory(_hash: string, _useNext?: boolean): Promise<GetScriptHashHistoryResult>;
     hashToHeader(_hash: string): Promise<BlockHeader>;
     nLockTimeIsFinal(_txOrLockTime: string | number[] | Transaction | number): Promise<boolean>;
-    getBeefBytes(txid: string): Promise<number[]>;
-    getBeefForTxid(txid: string): Promise<Beef>;
-    /**
-     * Get OrdFS metadata for an outpoint
-     * @throws {HttpError} on HTTP errors (check status for specifics)
-     */
-    getOrdfsMetadata(outpoint: string): Promise<OrdfsMetadata>;
-    /**
-     * Get BSV21 token data by txid from the overlay
-     * @throws {HttpError} on HTTP errors (check status for specifics)
-     */
-    getBsv21TokenByTxid(_tokenId: string, txid: string): Promise<Bsv21TransactionData>;
-    /**
-     * Get BSV21 token details (metadata) by token ID
-     * Results are cached since token details are immutable
-     * @throws {HttpError} on HTTP errors (check status for specifics)
-     */
-    getBsv21TokenDetails(tokenId: string): Promise<Bsv21TokenDetails>;
-    getServicesCallHistory(_reset?: boolean): ServicesCallHistory;
 }

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

@@ -0,0 +1,45 @@
+import type { ClientOptions, Policy, SubmitOptions, TransactionStatus } from "../types";
+import { BaseClient } from "./BaseClient";
+/**
+ * Client for /api/arcade/* routes.
+ * Provides transaction broadcast and status checking.
+ *
+ * Routes:
+ * - POST /tx - Submit single transaction
+ * - POST /txs - Submit multiple transactions
+ * - GET /tx/:txid - Get transaction status
+ * - GET /policy - Get mining policy
+ * - GET /events - SSE stream of transaction events
+ */
+export declare class ArcadeClient extends BaseClient {
+    constructor(baseUrl: string, options?: ClientOptions);
+    /**
+     * Submit a single transaction for broadcast
+     */
+    submitTransaction(rawTx: number[] | Uint8Array, options?: SubmitOptions): Promise<TransactionStatus>;
+    /**
+     * Submit a transaction as hex string
+     */
+    submitTransactionHex(rawTxHex: string, options?: SubmitOptions): Promise<TransactionStatus>;
+    /**
+     * Submit multiple transactions for broadcast
+     */
+    submitTransactions(rawTxs: (number[] | Uint8Array)[], options?: SubmitOptions): Promise<TransactionStatus[]>;
+    /**
+     * Get status of a submitted transaction
+     */
+    getStatus(txid: string): Promise<TransactionStatus>;
+    /**
+     * Get current mining policy
+     */
+    getPolicy(): Promise<Policy>;
+    /**
+     * Subscribe to transaction status events via SSE
+     * Returns unsubscribe function
+     */
+    subscribeEvents(callback: (status: TransactionStatus) => void, callbackToken?: string): () => void;
+    /**
+     * Build headers for submit requests
+     */
+    private buildSubmitHeaders;
+}

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

@@ -0,0 +1,32 @@
+import type { ClientOptions } from "../types";
+/**
+ * Base client with shared HTTP utilities for all 1sat-stack API clients.
+ * Provides timeout handling, error parsing, and request helpers.
+ */
+export declare class BaseClient {
+    protected readonly baseUrl: string;
+    protected readonly timeout: number;
+    protected readonly fetchFn: typeof fetch;
+    constructor(baseUrl: string, options?: ClientOptions);
+    /**
+     * Make a JSON request and parse the response
+     */
+    protected request<T>(path: string, init?: RequestInit): Promise<T>;
+    /**
+     * Make a request and return raw binary data
+     */
+    protected requestBinary(path: string, init?: RequestInit): Promise<Uint8Array>;
+    /**
+     * Make a request and return the raw Response object
+     * Useful for streaming responses
+     */
+    protected requestRaw(path: string, init?: RequestInit): Promise<Response>;
+    /**
+     * Parse error response into HttpError
+     */
+    private parseError;
+    /**
+     * Build query string from options object
+     */
+    protected buildQueryString(params: Record<string, string | number | boolean | string[] | undefined>): string;
+}

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

@@ -0,0 +1,26 @@
+import type { ClientOptions } from "../types";
+import { BaseClient } from "./BaseClient";
+/**
+ * Client for /api/beef/* routes.
+ * Provides BEEF data, raw transactions, and merkle proofs.
+ *
+ * Routes:
+ * - GET /:txid - Get BEEF for transaction
+ * - GET /:txid/raw - Get raw transaction bytes
+ * - GET /:txid/proof - Get merkle proof
+ */
+export declare class BeefClient extends BaseClient {
+    constructor(baseUrl: string, options?: ClientOptions);
+    /**
+     * Get BEEF (Background Evaluation Extended Format) for a transaction
+     */
+    getBeef(txid: string): Promise<Uint8Array>;
+    /**
+     * Get raw transaction bytes
+     */
+    getRawTx(txid: string): Promise<Uint8Array>;
+    /**
+     * Get merkle proof bytes for a mined transaction
+     */
+    getProof(txid: string): Promise<Uint8Array>;
+}

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

@@ -0,0 +1,46 @@
+import type { Bsv21TokenDetails, Bsv21TransactionData, ClientOptions, IndexedOutput } from "../types";
+import { BaseClient } from "./BaseClient";
+/**
+ * Client for /api/bsv21/* routes.
+ * Provides BSV21 token queries.
+ *
+ * Routes:
+ * - GET /:tokenId - Get token details
+ * - GET /:tokenId/blk/:height - Get token data at block height
+ * - GET /:tokenId/tx/:txid - Get token data for transaction
+ * - GET /:tokenId/:lockType/:address/balance - Get token balance
+ * - GET /:tokenId/:lockType/:address/unspent - Get unspent token UTXOs
+ * - GET /:tokenId/:lockType/:address/history - Get token transaction history
+ */
+export declare class Bsv21Client extends BaseClient {
+    private cache;
+    constructor(baseUrl: string, options?: ClientOptions);
+    /**
+     * Get token details (deploy data).
+     * Results are cached since token details are immutable.
+     */
+    getTokenDetails(tokenId: string): Promise<Bsv21TokenDetails>;
+    /**
+     * Get token transaction data for a specific txid
+     */
+    getTokenByTxid(tokenId: string, txid: string): Promise<Bsv21TransactionData>;
+    /**
+     * Get token balance for an address
+     * @param tokenId - Token ID (outpoint of deploy tx)
+     * @param lockType - Lock type (e.g., 'p2pkh', 'ordlock')
+     * @param address - Address to check
+     */
+    getBalance(tokenId: string, lockType: string, address: string): Promise<bigint>;
+    /**
+     * Get unspent token UTXOs for an address
+     */
+    getUnspent(tokenId: string, lockType: string, address: string): Promise<IndexedOutput[]>;
+    /**
+     * Get token transaction history for an address
+     */
+    getHistory(tokenId: string, lockType: string, address: string): Promise<IndexedOutput[]>;
+    /**
+     * Clear the token details cache
+     */
+    clearCache(): void;
+}

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

@@ -0,0 +1,62 @@
+import type { ChainTracker } from "@bsv/sdk";
+import type { BlockHeader, ClientOptions } from "../types";
+import { BaseClient } from "./BaseClient";
+/**
+ * Client for /api/chaintracks/* routes.
+ * Provides block header data and implements ChainTracker interface.
+ *
+ * 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
+ * - GET /header/hash/:hash - Get header by hash
+ */
+export declare class ChaintracksClient extends BaseClient implements ChainTracker {
+    private eventSource;
+    private subscribers;
+    constructor(baseUrl: string, options?: ClientOptions);
+    /**
+     * Get current blockchain height (ChainTracker interface)
+     */
+    currentHeight(): Promise<number>;
+    /**
+     * Validate merkle root for a given height (ChainTracker interface)
+     */
+    isValidRootForHeight(root: string, height: number): Promise<boolean>;
+    /**
+     * Get the network type (main or test)
+     */
+    getNetwork(): Promise<string>;
+    /**
+     * Get the current chain tip
+     */
+    getTip(): Promise<BlockHeader>;
+    /**
+     * Get block header by height
+     */
+    getHeaderByHeight(height: number): Promise<BlockHeader>;
+    /**
+     * Get block header by hash
+     */
+    getHeaderByHash(hash: string): Promise<BlockHeader>;
+    /**
+     * Get multiple headers as parsed BlockHeader objects
+     */
+    getHeaders(height: number, count: number): Promise<BlockHeader[]>;
+    /**
+     * Get raw header bytes for one or more headers
+     */
+    getHeaderBytes(height: number, count?: number): Promise<number[]>;
+    /**
+     * Subscribe to new block notifications via SSE
+     * Returns unsubscribe function
+     */
+    subscribe(callback: (header: BlockHeader) => void): () => void;
+    /**
+     * Close all connections
+     */
+    close(): void;
+}