@1sat/wallet-toolbox 0.0.5 → 0.0.7

package/dist/indexers/OriginIndexer.js

@@ -0,0 +1,240 @@
+import { HttpError } from "../errors";
+import { parseAddress } from "./parseAddress";
+import { Indexer, } from "./types";
+export class OriginIndexer extends Indexer {
+    owners;
+    network;
+    services;
+    tag = "origin";
+    name = "Origins";
+    constructor(owners, network, services) {
+        super(owners, network);
+        this.owners = owners;
+        this.network = network;
+        this.services = services;
+    }
+    /**
+     * 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.
+     */
+    async parse(txo) {
+        const satoshis = BigInt(txo.output.satoshis || 0);
+        // Only parse 1-satoshi outputs, exclude BSV-20 tokens
+        if (satoshis !== 1n)
+            return;
+        const insc = txo.data.insc?.data;
+        if (insc?.file?.type === "application/bsv-20")
+            return;
+        // Parse the address
+        const script = txo.output.lockingScript;
+        const address = parseAddress(script, 0, this.network);
+        // Start with placeholder origin - will be populated in summarize()
+        const origin = {
+            outpoint: "", // Will be set in summarize()
+            nonce: 0,
+            sigma: txo.data.sigma?.data,
+        };
+        // Merge current output's MAP data
+        const currentMap = txo.data.map?.data;
+        if (currentMap) {
+            origin.map = { ...currentMap };
+        }
+        // If current output has inscription, use it
+        if (insc) {
+            origin.insc = insc;
+        }
+        return {
+            data: origin,
+            tags: [], // Tags will be added in summarize() once origin is determined
+            owner: address && this.owners.has(address) ? address : undefined,
+            basket: "1sat",
+        };
+    }
+    /**
+     * Summarize determines origin tracking (transfer vs new origin) and
+     * fetches metadata from OrdFS for transfers.
+     */
+    async summarize(ctx) {
+        // First, calculate satoshi positions and determine origins for all outputs
+        await this.resolveOrigins(ctx);
+        // Now compute balance summary
+        let balance = 0;
+        let hasTag = false;
+        let icon;
+        let id = "";
+        // Check inputs
+        for (const spend of ctx.spends) {
+            if (spend.data[this.tag]) {
+                const origin = spend.data[this.tag].data;
+                if (spend.owner && this.owners.has(spend.owner)) {
+                    hasTag = true;
+                    balance--;
+                    if (!icon && origin?.insc?.file?.type.startsWith("image/")) {
+                        icon = origin?.outpoint;
+                        id = origin.map?.name || "";
+                    }
+                }
+            }
+        }
+        // Check outputs
+        for (const txo of ctx.txos) {
+            if (txo.data[this.tag]) {
+                if (txo.owner && this.owners.has(txo.owner)) {
+                    hasTag = true;
+                    balance++;
+                    const origin = txo.data.origin?.data;
+                    if (!icon && origin?.insc?.file?.type.startsWith("image/")) {
+                        icon = origin?.outpoint;
+                    }
+                }
+                // Clear file content before saving - content is loaded locally but shouldn't be persisted
+                const origin = txo.data[this.tag].data;
+                if (origin?.insc?.file) {
+                    origin.insc.file.content = [];
+                }
+            }
+        }
+        if (hasTag) {
+            return {
+                id,
+                amount: balance,
+                icon,
+            };
+        }
+    }
+    /**
+     * Resolve origins for all 1-sat outputs in the transaction.
+     * This determines whether each is a new origin or a transfer.
+     */
+    async resolveOrigins(ctx) {
+        // Calculate satoshi positions for all outputs
+        const satPositions = [];
+        let cumulative = 0n;
+        for (const txo of ctx.txos) {
+            satPositions.push(cumulative);
+            cumulative += BigInt(txo.output.satoshis || 0);
+        }
+        // Process each output that has origin data
+        for (let vout = 0; vout < ctx.txos.length; vout++) {
+            const txo = ctx.txos[vout];
+            const originData = txo.data[this.tag];
+            if (!originData)
+                continue;
+            const origin = originData.data;
+            const outSat = satPositions[vout];
+            // Track accumulated input satoshis to find which input contains our satoshi
+            let satsIn = 0n;
+            let sourceOutpoint;
+            for (const spend of ctx.spends) {
+                const spendSatoshis = BigInt(spend.output.satoshis || 0);
+                // Check if this input's satoshi range contains our output's satoshi
+                if (satsIn === outSat && spendSatoshis === 1n) {
+                    sourceOutpoint = spend.outpoint.toString();
+                    break;
+                }
+                satsIn += spendSatoshis;
+                // If we've passed our satoshi position, this is a new origin
+                if (satsIn > outSat) {
+                    break;
+                }
+            }
+            if (sourceOutpoint) {
+                // Transfer - fetch metadata from OrdFS
+                try {
+                    const metadata = await this.services.ordfs.getMetadata(sourceOutpoint, 0);
+                    origin.outpoint = metadata.origin || sourceOutpoint;
+                    origin.nonce = metadata.sequence + 1;
+                    // Merge inherited map with current
+                    if (metadata.map) {
+                        origin.map = { ...metadata.map, ...(origin.map || {}) };
+                    }
+                    // If no inscription on current output, use metadata from source
+                    // and potentially fetch text content
+                    if (!origin.insc) {
+                        origin.insc = {
+                            file: {
+                                hash: "",
+                                size: metadata.contentLength,
+                                type: metadata.contentType,
+                                content: [],
+                            },
+                        };
+                        // Fetch text content if it qualifies
+                        const contentType = metadata.contentType.toLowerCase();
+                        const isTextContent = contentType.startsWith("text/") ||
+                            contentType === "application/json";
+                        if (isTextContent && metadata.contentLength <= 1000) {
+                            try {
+                                const { data } = await this.services.ordfs.getContent(origin.outpoint || sourceOutpoint);
+                                if (data) {
+                                    originData.content = new TextDecoder().decode(data);
+                                }
+                            }
+                            catch {
+                                // Ignore content fetch errors
+                            }
+                        }
+                    }
+                }
+                catch (e) {
+                    if (e instanceof HttpError && e.status === 404) {
+                        // Source outpoint not found in OrdFS - treat as new origin
+                        origin.outpoint = txo.outpoint.toString();
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+            }
+            else {
+                // New origin
+                origin.outpoint = txo.outpoint.toString();
+            }
+            // Validate parent if inscription claims one
+            const insc = txo.data.insc?.data;
+            if (insc?.parent) {
+                try {
+                    const metadata = await this.services.ordfs.getMetadata(txo.outpoint.toString(), 0);
+                    if (metadata.parent !== insc.parent) {
+                        if (origin.insc) {
+                            origin.insc.parent = undefined;
+                        }
+                    }
+                }
+                catch (e) {
+                    if (e instanceof HttpError && e.status === 404) {
+                        // Can't verify parent claim - remove it
+                        if (origin.insc) {
+                            origin.insc.parent = undefined;
+                        }
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+            }
+            // Clear large file content to save space
+            if (origin.insc?.file?.size && origin.insc.file.size > 4096) {
+                origin.insc.file.content = [];
+            }
+            // Now add tags since origin is determined
+            if (txo.owner && this.owners.has(txo.owner)) {
+                originData.tags.push(`origin:${origin.outpoint || ""}`);
+                if (origin.insc?.file?.type) {
+                    const fullType = origin.insc.file.type;
+                    const baseType = fullType.split(";")[0].trim();
+                    const category = baseType.split("/")[0];
+                    originData.tags.push(`type:${category}`);
+                    originData.tags.push(`type:${baseType}`);
+                }
+                // Extract name from map data
+                const name = (origin.map?.name ??
+                    origin.map?.subTypeData?.name);
+                if (name) {
+                    originData.tags.push(`name:${name}`);
+                }
+            }
+        }
+    }
+}

package/dist/indexers/Outpoint.js

@@ -0,0 +1,53 @@
+import { Utils } from "@bsv/sdk";
+export class Outpoint {
+    txid;
+    vout;
+    constructor(txidOrOutpoint, vout) {
+        if (vout !== undefined) {
+            this.vout = vout;
+            if (typeof txidOrOutpoint === "string") {
+                this.txid = txidOrOutpoint;
+            }
+            else if (Array.isArray(txidOrOutpoint)) {
+                this.txid = Utils.toHex(txidOrOutpoint);
+            }
+            else {
+                throw new Error("Invalid Outpoint");
+            }
+        }
+        else if (Array.isArray(txidOrOutpoint)) {
+            const reader = new Utils.Reader(txidOrOutpoint);
+            this.txid = Utils.toHex(reader.read(32).reverse());
+            this.vout = reader.readInt32LE();
+        }
+        else if (typeof txidOrOutpoint === "string") {
+            this.txid = txidOrOutpoint.substring(0, 64);
+            this.vout = Number.parseInt(txidOrOutpoint.substring(65), 10);
+        }
+        else if (typeof txidOrOutpoint === "object") {
+            this.txid = txidOrOutpoint.txid;
+            this.vout = txidOrOutpoint.vout;
+        }
+        else {
+            throw new Error("Invalid Outpoint");
+        }
+    }
+    toString() {
+        return `${this.txid}_${this.vout}`;
+    }
+    toBinary() {
+        const writer = new Utils.Writer();
+        writer.write(Utils.toArray(this.txid, "hex").reverse());
+        writer.writeUInt32LE(this.vout);
+        return writer.toArray();
+    }
+    toBEBinary() {
+        const writer = new Utils.Writer();
+        writer.write(Utils.toArray(this.txid, "hex"));
+        writer.writeUInt32BE(this.vout);
+        return writer.toArray();
+    }
+    toJSON() {
+        return this.toString();
+    }
+}

package/dist/indexers/SigmaIndexer.js

@@ -0,0 +1,133 @@
+import { BSM, BigNumber, Hash, OP, Script, Signature, Utils } from "@bsv/sdk";
+import { Indexer, } from "./types";
+export class SigmaIndexer extends Indexer {
+    owners;
+    network;
+    tag = "sigma";
+    name = "Sigma";
+    constructor(owners = new Set(), network = "mainnet") {
+        super(owners, network);
+        this.owners = owners;
+        this.network = network;
+    }
+    /**
+     * Parse extracts raw sigma protocol data without validation.
+     * Validation requires ctx.spends and is done in summarize().
+     */
+    async parse(txo) {
+        const script = txo.output.lockingScript;
+        const vout = txo.outpoint.vout;
+        let retPos = 0;
+        const sigmas = [];
+        for (let i = retPos + 1; i < script.chunks.length; i++) {
+            const chunk = script.chunks[i];
+            if (!retPos && chunk.op === OP.OP_RETURN) {
+                retPos = i;
+                continue;
+            }
+            if (!retPos || chunk.data?.length !== 1 || chunk.data[0] !== 0x7c) {
+                continue;
+            }
+            if (Utils.toUTF8(script.chunks[++i]?.data || []) !== "SIGMA") {
+                continue;
+            }
+            const sigma = {
+                algorithm: script.chunks[++i]?.data
+                    ? Utils.toUTF8(script.chunks[i].data || [])
+                    : "",
+                address: script.chunks[++i]?.data
+                    ? Utils.toUTF8(script.chunks[i].data || [])
+                    : "",
+                signature: script.chunks[++i]?.data || [],
+                vin: script.chunks[++i]?.data
+                    ? Number.parseInt(Utils.toUTF8(script.chunks[i].data || []))
+                    : -1,
+                valid: false, // Will be validated in summarize()
+            };
+            // Use vout as default vin if not specified
+            if (sigma.vin === -1)
+                sigma.vin = vout;
+            sigmas.push(sigma);
+        }
+        if (!sigmas.length)
+            return;
+        return { data: sigmas, tags: [] };
+    }
+    /**
+     * Validate all sigma signatures against ctx.spends.
+     */
+    async summarize(ctx, _isBroadcasted) {
+        for (const txo of ctx.txos) {
+            const sigmaData = txo.data[this.tag];
+            if (!sigmaData)
+                continue;
+            const sigmas = sigmaData.data;
+            const script = txo.output.lockingScript;
+            for (const sigma of sigmas) {
+                // Find the dataPos by re-scanning for this sigma
+                const dataPos = this.findSigmaDataPos(script, sigma);
+                if (dataPos === -1)
+                    continue;
+                // Get the spend for this sigma's vin
+                const spend = ctx.spends[sigma.vin];
+                if (!spend)
+                    continue;
+                const bw = new Utils.Writer();
+                bw.write(Utils.toArray(spend.outpoint.txid, "hex"));
+                bw.writeUInt32LE(spend.outpoint.vout);
+                const inputHash = Hash.sha256(bw.toArray());
+                const dataScript = new Script();
+                dataScript.chunks = script.chunks.slice(0, dataPos);
+                const outputHash = Hash.sha256(dataScript.toBinary());
+                const msgHash = Hash.sha256(inputHash.concat(outputHash));
+                const signature = Signature.fromCompact(sigma.signature);
+                for (let recovery = 0; recovery < 4; recovery++) {
+                    try {
+                        const publicKey = signature.RecoverPublicKey(recovery, new BigNumber(BSM.magicHash(msgHash)));
+                        const sigFitsPubkey = BSM.verify(msgHash, signature, publicKey);
+                        const pubkeyAddress = publicKey.toAddress(this.network === "mainnet" ? "mainnet" : "testnet");
+                        if (sigFitsPubkey && pubkeyAddress === sigma.address) {
+                            sigma.valid = true;
+                            break;
+                        }
+                    }
+                    catch {
+                        // try next recovery
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Find the data position for a sigma in the script (position before the pipe separator).
+     */
+    findSigmaDataPos(script, targetSigma) {
+        let retPos = 0;
+        for (let i = 1; i < script.chunks.length; i++) {
+            const chunk = script.chunks[i];
+            if (!retPos && chunk.op === OP.OP_RETURN) {
+                retPos = i;
+                continue;
+            }
+            if (!retPos || chunk.data?.length !== 1 || chunk.data[0] !== 0x7c) {
+                continue;
+            }
+            if (Utils.toUTF8(script.chunks[i + 1]?.data || []) !== "SIGMA") {
+                continue;
+            }
+            const dataPos = i;
+            // Check if this is the target sigma by comparing address and signature
+            const address = script.chunks[i + 3]?.data
+                ? Utils.toUTF8(script.chunks[i + 3].data || [])
+                : "";
+            const sig = script.chunks[i + 4]?.data || [];
+            if (address === targetSigma.address &&
+                sig.length === targetSigma.signature.length &&
+                sig.every((b, idx) => b === targetSigma.signature[idx])) {
+                return dataPos;
+            }
+        }
+        return -1;
+    }
+}

package/dist/indexers/TransactionParser.d.ts

@@ -0,0 +1,53 @@
+import { Transaction } from "@bsv/sdk";
+import type { OneSatServices } from "../services/OneSatServices";
+import type { Indexer } from "./types";
+/**
+ * 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.js

@@ -0,0 +1,13 @@
+export { Indexer, } from "./types";
+export { Outpoint } from "./Outpoint";
+export { parseAddress } from "./parseAddress";
+export { FundIndexer } from "./FundIndexer";
+export { LockIndexer } from "./LockIndexer";
+export { InscriptionIndexer, } from "./InscriptionIndexer";
+export { SigmaIndexer } from "./SigmaIndexer";
+export { MapIndexer } from "./MapIndexer";
+export { OriginIndexer } from "./OriginIndexer";
+export { Bsv21Indexer, deriveFundAddress } from "./Bsv21Indexer";
+export { OrdLockIndexer, Listing } from "./OrdLockIndexer";
+export { OpNSIndexer } from "./OpNSIndexer";
+export { CosignIndexer } from "./CosignIndexer";

package/dist/indexers/parseAddress.js

@@ -0,0 +1,24 @@
+import { OP, Utils } 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 function parseAddress(script, offset = 0, network = "mainnet") {
+    if (script.chunks[0 + offset]?.op !== OP.OP_DUP)
+        return "";
+    if (script.chunks[1 + offset]?.op !== OP.OP_HASH160)
+        return "";
+    if (script.chunks[2 + offset]?.data?.length !== 20)
+        return "";
+    if (script.chunks[3 + offset]?.op !== OP.OP_EQUALVERIFY)
+        return "";
+    if (script.chunks[4 + offset]?.op !== OP.OP_CHECKSIG)
+        return "";
+    const data = script.chunks[2 + offset].data;
+    if (!data)
+        return "";
+    return Utils.toBase58Check(data, network === "mainnet" ? [0] : [111]);
+}

package/dist/indexers/types.js

@@ -0,0 +1,18 @@
+/**
+ * Base indexer class that all indexers extend
+ */
+export class Indexer {
+    owners;
+    network;
+    constructor(owners = new Set(), network = "mainnet") {
+        this.owners = owners;
+        this.network = network;
+    }
+    /**
+     * Post-parse phase with full transaction context.
+     * Used for cross-output/cross-input validation and transaction-level summarization.
+     */
+    async summarize(_ctx, _isBroadcasted) {
+        return undefined;
+    }
+}

package/dist/services/OneSatServices.d.ts

@@ -1,8 +1,16 @@
 import { Beef, Transaction } from "@bsv/sdk";
-import type { WalletStorageManager } from "@bsv/wallet-toolbox/mobile";
-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 { TableOutput, WalletStorageManager, sdk as toolboxSdk } from "@bsv/wallet-toolbox";
+type Chain = toolboxSdk.Chain;
+type BlockHeader = toolboxSdk.BlockHeader;
+type GetMerklePathResult = toolboxSdk.GetMerklePathResult;
+type GetRawTxResult = toolboxSdk.GetRawTxResult;
+type GetScriptHashHistoryResult = toolboxSdk.GetScriptHashHistoryResult;
+type GetStatusForTxidsResult = toolboxSdk.GetStatusForTxidsResult;
+type GetUtxoStatusOutputFormat = toolboxSdk.GetUtxoStatusOutputFormat;
+type GetUtxoStatusResult = toolboxSdk.GetUtxoStatusResult;
+type PostBeefResult = toolboxSdk.PostBeefResult;
+type ServicesCallHistory = toolboxSdk.ServicesCallHistory;
+type WalletServices = toolboxSdk.WalletServices;
 import { ArcadeClient, BeefClient, Bsv21Client, ChaintracksClient, OrdfsClient, OwnerClient, TxoClient } from "./client";
 import type { Capability, SyncOutput } from "./types";
 export type { SyncOutput };