@1sat/wallet-toolbox 0.0.1

package/dist/indexers/Bsv21Indexer.d.ts

@@ -0,0 +1,35 @@
+import { Indexer, type IndexData, type IndexSummary, type ParseContext } from "./types";
+import type { OneSatServices } from "../services/OneSatServices";
+export interface Bsv21 {
+    id: string;
+    op: string;
+    amt: bigint;
+    dec: number;
+    sym?: string;
+    icon?: string;
+    status: "valid" | "invalid" | "pending";
+    reason?: string;
+    fundAddress: string;
+}
+/**
+ * Bsv21Indexer identifies and validates BSV21 tokens.
+ * These are 1-sat outputs with application/bsv-20 inscription type.
+ *
+ * Data structure: Bsv21 with id, op, amt, dec, status, etc.
+ *
+ * Basket: 'bsv21'
+ * Events: address, id, status
+ */
+export declare class Bsv21Indexer extends Indexer {
+    owners: Set<string>;
+    network: "mainnet" | "testnet";
+    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>;
+    serialize(bsv21: Bsv21): string;
+    deserialize(str: string): Bsv21;
+}
+export declare function deriveFundAddress(idOrOutpoint: string | number[]): string;

package/dist/indexers/CosignIndexer.d.ts

@@ -0,0 +1,13 @@
+import { Indexer, type IndexData, type ParseContext } from "./types";
+export interface Cosign {
+    address: string;
+    cosigner: string;
+}
+export declare class CosignIndexer 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>;
+}

package/dist/indexers/FundIndexer.d.ts

@@ -0,0 +1,19 @@
+import { Indexer, type IndexData, type IndexSummary, type ParseContext } from "./types";
+/**
+ * FundIndexer identifies P2PKH outputs to owned addresses.
+ * These are standard "funding" UTXOs that can be spent normally.
+ *
+ * Data structure: string (address)
+ *
+ * Basket: 'fund'
+ * Tags: None
+ */
+export declare class FundIndexer 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>;
+    summerize(ctx: ParseContext): Promise<IndexSummary | undefined>;
+}

package/dist/indexers/InscriptionIndexer.d.ts

@@ -0,0 +1,31 @@
+import { Indexer, type IndexData, type ParseContext } from "./types";
+export interface File {
+    hash: string;
+    size: number;
+    type: string;
+    content: number[];
+}
+export interface Inscription {
+    file?: File;
+    fields?: {
+        [key: string]: string;
+    };
+    parent?: string;
+}
+/**
+ * InscriptionIndexer identifies and parses ordinal inscriptions.
+ * These are outputs with exactly 1 satoshi containing OP_FALSE OP_IF "ord" envelope.
+ *
+ * Data structure: Inscription with file, fields, and optional parent
+ *
+ * Basket: None (no basket assignment - this is preliminary data for other indexers)
+ * Events: address for owned outputs
+ */
+export declare class InscriptionIndexer 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>;
+}

package/dist/indexers/LockIndexer.d.ts

@@ -0,0 +1,10 @@
+import { Indexer, type IndexData, type IndexSummary, type ParseContext } 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>;
+}

package/dist/indexers/MapIndexer.d.ts

@@ -0,0 +1,14 @@
+import { Script } from "@bsv/sdk";
+import { Indexer, type IndexData, type ParseContext } from "./types";
+export declare const MAP_PROTO = "1PuQa7K62MiKCtssSLKy1kh56WWU7MtUR5";
+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>;
+    static parseMap(script: Script, mapPos: number): {
+        [key: string]: unknown;
+    } | undefined;
+}

package/dist/indexers/OpNSIndexer.d.ts

@@ -0,0 +1,9 @@
+import { Indexer, type IndexData, type ParseContext } 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>;
+}

package/dist/indexers/OrdLockIndexer.d.ts

@@ -0,0 +1,17 @@
+import { Indexer, type IndexData, type ParseContext, type IndexSummary } from "./types";
+export declare class Listing {
+    payout: number[];
+    price: bigint;
+    constructor(payout?: number[], price?: bigint);
+}
+export declare class OrdLockIndexer 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>;
+    summerize(ctx: ParseContext): Promise<IndexSummary | undefined>;
+    serialize(listing: Listing): string;
+    deserialize(str: string): Listing;
+}

package/dist/indexers/OriginIndexer.d.ts

@@ -0,0 +1,23 @@
+import { Indexer, type IndexData, type ParseContext, type IndexSummary } from "./types";
+import type { Inscription } from "./InscriptionIndexer";
+import type { Sigma } from "./SigmaIndexer";
+import type { OneSatServices } from "../services/OneSatServices";
+export interface Origin {
+    outpoint?: string;
+    nonce?: number;
+    insc?: Inscription;
+    map?: {
+        [key: string]: unknown;
+    };
+    sigma?: Sigma[];
+}
+export declare class OriginIndexer extends Indexer {
+    owners: Set<string>;
+    network: "mainnet" | "testnet";
+    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>;
+}

package/dist/indexers/Outpoint.d.ts

@@ -0,0 +1,9 @@
+export declare class Outpoint {
+    txid: string;
+    vout: number;
+    constructor(txidOrOutpoint: string | number[] | Outpoint, vout?: number);
+    toString(): string;
+    toBinary(): number[];
+    toBEBinary(): number[];
+    toJSON(): string;
+}

package/dist/indexers/SigmaIndexer.d.ts

@@ -0,0 +1,16 @@
+import { Indexer, type IndexData, type ParseContext } from "./types";
+export interface Sigma {
+    algorithm: string;
+    address: string;
+    signature: number[];
+    vin: number;
+    valid: boolean;
+}
+export declare class SigmaIndexer 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>;
+}

package/dist/indexers/TransactionParser.d.ts

@@ -0,0 +1,53 @@
+import { Transaction } from "@bsv/sdk";
+import type { Indexer } from "./types";
+import type { OneSatServices } from "../services/OneSatServices";
+/**
+ * Represents the result of parsing a single output
+ */
+export interface ParsedOutput {
+    vout: number;
+    basket: string;
+    tags: string[];
+    customInstructions?: unknown;
+}
+/**
+ * Represents the result of parsing an entire transaction
+ */
+export interface ParseResult {
+    outputs: ParsedOutput[];
+    summary?: unknown;
+}
+/**
+ * TransactionParser runs indexers over a transaction to extract
+ * basket, tags, and custom instructions for wallet-toolbox.
+ *
+ * This is a stripped-down version of TxoStore.ingest() that only
+ * handles parsing without SPV verification or storage.
+ */
+export declare class TransactionParser {
+    indexers: Indexer[];
+    owners: Set<string>;
+    private services;
+    constructor(indexers: Indexer[], owners: Set<string>, services: OneSatServices);
+    /**
+     * Parse a transaction and extract wallet-toolbox metadata
+     */
+    parse(tx: Transaction, isBroadcasted: boolean): Promise<ParseResult>;
+    /**
+     * Parse all inputs - run indexers on source outputs to populate ctx.spends
+     */
+    private parseInputs;
+    /**
+     * Load source transactions for all inputs and set them on tx.inputs[].sourceTransaction
+     */
+    private loadSourceTransactions;
+    /**
+     * Build minimal parse context from transaction
+     */
+    private buildContext;
+    /**
+     * Convert parsed context to wallet-toolbox format with baskets and tags
+     * Filters outputs to only return those owned by addresses in the owners set
+     */
+    private convertToWalletToolboxFormat;
+}

package/dist/indexers/index.d.ts

@@ -0,0 +1,15 @@
+export { Indexer, type IndexData, type IndexSummary, type ParseContext, 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 { SigmaIndexer, type Sigma } from "./SigmaIndexer";
+export { MapIndexer, MAP_PROTO } 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";

package/dist/indexers/parseAddress.d.ts

@@ -0,0 +1,9 @@
+import { type Script } from "@bsv/sdk";
+/**
+ * Parse a P2PKH address from a locking script
+ * @param script - The locking script to parse
+ * @param offset - Chunk offset (default 0)
+ * @param network - Network type for address encoding
+ * @returns Base58Check encoded address or empty string if not P2PKH
+ */
+export declare function parseAddress(script: Script, offset?: number, network?: "mainnet" | "testnet"): string;

package/dist/indexers/types.d.ts

@@ -0,0 +1,99 @@
+import type { Transaction } from "@bsv/sdk";
+import type { Outpoint } from "./Outpoint";
+/**
+ * BSV21 token data structure from overlay API
+ */
+export interface Bsv21TokenData {
+    id: string;
+    op: string;
+    amt: string;
+    sym?: string;
+    dec?: number;
+    icon?: string;
+    address?: string;
+}
+/**
+ * BSV21 output data from overlay API
+ */
+export interface Bsv21OutputData {
+    txid: string;
+    vout: number;
+    data: {
+        bsv21: Bsv21TokenData;
+    };
+    script: string;
+    satoshis: number;
+    spend: string | null;
+    score: number;
+}
+/**
+ * BSV21 transaction data from overlay API
+ */
+export interface Bsv21TransactionData {
+    txid: string;
+    inputs: Bsv21OutputData[];
+    outputs: Bsv21OutputData[];
+    beef?: string;
+}
+/**
+ * IndexData contains the parsed data and tags from an indexer
+ * Tags are concatenated strings in the format "key:value" for searchability
+ */
+export interface IndexData {
+    data: unknown;
+    tags: string[];
+}
+/**
+ * IndexSummary contains transaction-level summary information
+ */
+export interface IndexSummary {
+    id?: string;
+    amount?: number;
+    icon?: string;
+    data?: unknown;
+}
+/**
+ * Minimal transaction output structure used during parsing
+ */
+export interface Txo {
+    satoshis: bigint;
+    script: number[];
+    owner?: string;
+    basket?: string;
+    data: {
+        [tag: string]: IndexData;
+    };
+    outpoint: Outpoint;
+}
+/**
+ * Minimal context structure for indexer parsing
+ */
+export interface ParseContext {
+    tx: Transaction;
+    txid: string;
+    txos: Txo[];
+    spends: Txo[];
+    summary: {
+        [tag: string]: IndexSummary;
+    };
+    indexers: Indexer[];
+}
+/**
+ * Base indexer class that all indexers extend
+ */
+export declare abstract class Indexer {
+    owners: Set<string>;
+    network: "mainnet" | "testnet";
+    abstract tag: string;
+    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.
+     */
+    abstract parse(ctx: ParseContext, vout: number, isBroadcasted: boolean): Promise<IndexData | undefined>;
+    /**
+     * Evaluates the index data for the entire transaction and returns a summary.
+     */
+    summerize(_ctx: ParseContext, _isBroadcasted: boolean): Promise<IndexSummary | undefined>;
+}

package/dist/services/OneSatServices.d.ts

@@ -0,0 +1,83 @@
+import { Beef, ChainTracker, 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 { 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;
+}
+/**
+ * WalletServices implementation for 1Sat ecosystem.
+ *
+ * Data sources:
+ * - ordfs-server - Block headers, merkle proofs, raw transactions
+ * - OneSat API - Transaction broadcasting
+ */
+export declare class OneSatServices implements WalletServices {
+    chain: Chain;
+    private ordfsBaseUrl;
+    readonly onesatBaseUrl: string;
+    private bsv21TokenCache;
+    private chainTracker;
+    private storage?;
+    constructor(chain: Chain, ordfsUrl?: string, onesatUrl?: string, storage?: WalletStorageManager);
+    getChainTracker(): Promise<ChainTracker>;
+    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[]>;
+    hashOutputScript(script: string): string;
+    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/signers/ReadOnlySigner.d.ts

@@ -0,0 +1,15 @@
+import { type KeyDeriverApi, type PrivateKey, type WalletProtocol, type Counterparty } from "@bsv/sdk";
+/**
+ * A read-only KeyDeriver that exposes an identity key but throws on any signing/derivation operation.
+ * Used when the wallet is instantiated with only a public key.
+ */
+export declare class ReadOnlySigner implements KeyDeriverApi {
+    readonly identityKey: string;
+    readonly rootKey: PrivateKey;
+    constructor(identityPublicKey: string);
+    derivePrivateKey(_protocolID: WalletProtocol, _keyID: string, _counterparty: Counterparty): never;
+    derivePublicKey(_protocolID: WalletProtocol, _keyID: string, _counterparty: Counterparty, _forSelf?: boolean): never;
+    deriveSymmetricKey(_protocolID: WalletProtocol, _keyID: string, _counterparty: Counterparty): never;
+    revealCounterpartySecret(_counterparty: Counterparty): never;
+    revealSpecificSecret(_counterparty: Counterparty, _protocolID: WalletProtocol, _keyID: string): never;
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@1sat/wallet-toolbox",
+  "version": "0.0.1",
+  "description": "BSV wallet library extending @bsv/wallet-toolbox with 1Sat Ordinals protocol support",
+  "author": "1Sat Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/b-open-io/1sat-wallet-toolbox.git"
+  },
+  "keywords": [
+    "bsv",
+    "bitcoin",
+    "ordinals",
+    "1sat",
+    "wallet"
+  ],
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target browser --define 'process.env={}' --define 'global=globalThis' --sourcemap=inline && tsc --emitDeclarationOnly",
+    "dev": "tsc --watch",
+    "lint": "biome check src",
+    "lint:fix": "biome check --write src",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "@bsv/sdk": "^1.9.24",
+    "@bsv/wallet-toolbox": "^1.7.14",
+    "buffer": "^6.0.3"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "@types/bun": "^1.3.4",
+    "typescript": "^5.9.3"
+  }
+}