@1sat/wallet-toolbox 0.0.5 → 0.0.7

package/dist/indexers/Bsv21Indexer.js

@@ -0,0 +1,232 @@
+import { BSV21 } from "@bopen-io/ts-templates";
+import { HD, Hash, Utils } from "@bsv/sdk";
+import { HttpError } from "../errors";
+import { Indexer, } from "./types";
+const FEE_XPUB = "xpub661MyMwAqRbcF221R74MPqdipLsgUevAAX4hZP2rywyEeShpbe3v2r9ciAvSGT6FB22TEmFLdUyeEDJL4ekG8s9H5WXbzDQPr6eW1zEYYy9";
+const hdKey = HD.fromString(FEE_XPUB);
+/**
+ * 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: id, id:status, bsv21:amt
+ */
+export class Bsv21Indexer extends Indexer {
+    owners;
+    network;
+    services;
+    tag = "bsv21";
+    name = "BSV21 Tokens";
+    constructor(owners, network, services) {
+        super(owners, network);
+        this.owners = owners;
+        this.network = network;
+        this.services = services;
+    }
+    async parse(txo) {
+        const lockingScript = txo.output.lockingScript;
+        // Use template decode
+        const decoded = BSV21.decode(lockingScript);
+        if (!decoded)
+            return;
+        const outpoint = txo.outpoint;
+        const tokenData = decoded.tokenData;
+        // Determine token ID - for deploy ops it's this outpoint, otherwise from inscription
+        const tokenId = tokenData.id || outpoint.toString();
+        // Determine initial status:
+        // - deploy ops (deploy+mint, deploy+auth) are always valid (they create the token)
+        // - transfer/burn ops start as pending until validated in summarize()
+        const isDeploy = tokenData.op.startsWith("deploy");
+        const initialStatus = isDeploy ? "valid" : "pending";
+        // Create indexer data structure with basic info from inscription
+        const bsv21 = {
+            id: tokenId,
+            op: tokenData.op,
+            amt: decoded.getAmount(),
+            dec: decoded.getDecimals(),
+            sym: tokenData.sym,
+            icon: tokenData.icon,
+            status: initialStatus,
+            fundAddress: deriveFundAddress(outpoint.toBEBinary()),
+        };
+        // For non-deploy ops, fetch token metadata from server (cached)
+        // This ensures we always have sym, dec, icon for any token
+        if (!isDeploy) {
+            try {
+                const details = await this.services.bsv21.getTokenDetails(tokenId);
+                bsv21.sym = details.sym;
+                bsv21.icon = resolveIcon(details.icon, tokenId);
+                bsv21.dec = details.dec;
+            }
+            catch (e) {
+                // Token not found on server - could be unconfirmed or invalid
+                // Keep local values from inscription, status remains pending
+                if (!(e instanceof HttpError && e.status === 404)) {
+                    throw e;
+                }
+            }
+        }
+        else {
+            // For deploy ops, resolve relative icon reference if present
+            bsv21.icon = resolveIcon(bsv21.icon, tokenId);
+        }
+        // Validate amount range
+        if (bsv21.amt <= 0n || bsv21.amt > 2n ** 64n - 1n)
+            return;
+        const tags = [];
+        if (txo.owner && this.owners.has(txo.owner)) {
+            // Use id:tokenId:status format for querying by token and status
+            tags.push(`id:${bsv21.id}:${bsv21.status}`);
+            tags.push(`amt:${bsv21.amt.toString()}`);
+            // Add metadata tags for efficient querying
+            if (bsv21.sym)
+                tags.push(`sym:${bsv21.sym}`);
+            if (bsv21.icon)
+                tags.push(`icon:${bsv21.icon}`);
+            tags.push(`dec:${bsv21.dec}`);
+        }
+        return {
+            data: bsv21,
+            tags,
+            basket: "bsv21",
+        };
+    }
+    async summarize(ctx) {
+        // Track token flows per token ID for validation
+        const tokenFlows = {};
+        let summaryToken;
+        let summaryBalance = 0;
+        // Process inputs from ctx.spends (already parsed)
+        for (const spend of ctx.spends) {
+            const bsv21 = spend.data.bsv21;
+            if (!bsv21)
+                continue;
+            const tokenData = bsv21.data;
+            // Initialize token tracking
+            if (!tokenFlows[tokenData.id]) {
+                tokenFlows[tokenData.id] = {
+                    tokensIn: 0n,
+                    tokensOut: 0n,
+                    inputsPending: false,
+                };
+            }
+            const flow = tokenFlows[tokenData.id];
+            // Validate this input exists on the overlay
+            try {
+                await this.services.bsv21.getTokenByTxid(tokenData.id, spend.outpoint.txid);
+            }
+            catch (e) {
+                if (e instanceof HttpError && e.status === 404) {
+                    // Input not on overlay yet - outputs will be pending
+                    flow.inputsPending = true;
+                }
+                else {
+                    throw e;
+                }
+            }
+            // Accumulate tokens in
+            flow.tokensIn += tokenData.amt;
+            if (!summaryToken)
+                summaryToken = tokenData;
+            // Track balance change for owned inputs
+            if (summaryToken &&
+                tokenData.id === summaryToken.id &&
+                spend.owner &&
+                this.owners.has(spend.owner)) {
+                summaryBalance -= Number(tokenData.amt);
+            }
+        }
+        // Process outputs: accumulate tokensOut and validate
+        for (const txo of ctx.txos) {
+            const bsv21 = txo.data.bsv21;
+            if (!bsv21 || !["transfer", "burn"].includes(bsv21.data.op))
+                continue;
+            const tokenData = bsv21.data;
+            const flow = tokenFlows[tokenData.id];
+            if (flow) {
+                flow.tokensOut += tokenData.amt;
+            }
+            else {
+                // No inputs for this token - invalid (attempting to create tokens from nothing)
+                tokenData.status = "invalid";
+            }
+            if (!summaryToken)
+                summaryToken = tokenData;
+            // Track balance change for owned outputs
+            if (summaryToken &&
+                tokenData.id === summaryToken.id &&
+                txo.owner &&
+                this.owners.has(txo.owner)) {
+                summaryBalance += Number(tokenData.amt);
+            }
+        }
+        // Finalize validation and apply status to outputs
+        for (const txo of ctx.txos) {
+            const bsv21 = txo.data.bsv21;
+            if (!bsv21 || !["transfer", "burn"].includes(bsv21.data.op))
+                continue;
+            const tokenData = bsv21.data;
+            if (tokenData.status === "invalid")
+                continue; // Already marked invalid
+            const flow = tokenFlows[tokenData.id];
+            if (!flow)
+                continue;
+            // Determine final status
+            if (flow.inputsPending) {
+                tokenData.status = "pending";
+            }
+            else if (flow.tokensIn >= flow.tokensOut) {
+                tokenData.status = "valid";
+            }
+            else {
+                tokenData.status = "invalid";
+            }
+        }
+        if (summaryToken?.sym) {
+            return {
+                id: summaryToken.sym,
+                amount: summaryBalance / 10 ** (summaryToken.dec || 0),
+                icon: summaryToken.icon,
+            };
+        }
+    }
+    serialize(bsv21) {
+        return JSON.stringify({
+            ...bsv21,
+            amt: bsv21.amt.toString(10),
+        });
+    }
+    deserialize(str) {
+        const obj = JSON.parse(str);
+        return {
+            ...obj,
+            amt: BigInt(obj.amt),
+        };
+    }
+}
+/**
+ * Resolve a relative icon reference to an absolute outpoint.
+ * If icon starts with "_", it's a relative reference to another output
+ * in the same transaction as the token deploy. We resolve it by
+ * prepending the token ID's txid.
+ *
+ * Example: tokenId = "abc123...def_0", icon = "_1" -> "abc123...def_1"
+ */
+function resolveIcon(icon, tokenId) {
+    if (!icon || !icon.startsWith("_"))
+        return icon;
+    // Token ID format is "txid_vout", extract the txid
+    const txid = tokenId.substring(0, 64);
+    // Icon format is "_vout", combine with txid
+    return `${txid}${icon}`;
+}
+export function deriveFundAddress(idOrOutpoint) {
+    const hash = Hash.sha256(idOrOutpoint);
+    const reader = new Utils.Reader(hash);
+    let path = `m/21/${reader.readUInt32BE() >> 1}`;
+    reader.pos = 24;
+    path += `/${reader.readUInt32BE() >> 1}`;
+    return hdKey.derive(path).pubKey.toAddress();
+}

package/dist/indexers/CosignIndexer.js

@@ -0,0 +1,25 @@
+import { Cosign } from "@bopen-io/ts-templates";
+import { Indexer } from "./types";
+export class CosignIndexer extends Indexer {
+    owners;
+    network;
+    tag = "cosign";
+    name = "Cosign";
+    constructor(owners = new Set(), network = "mainnet") {
+        super(owners, network);
+        this.owners = owners;
+        this.network = network;
+    }
+    async parse(txo) {
+        const lockingScript = txo.output.lockingScript;
+        // Use template decode
+        const decoded = Cosign.decode(lockingScript, this.network === "mainnet");
+        if (!decoded)
+            return;
+        return {
+            data: decoded,
+            tags: [],
+            owner: decoded.address,
+        };
+    }
+}

package/dist/indexers/FundIndexer.js

@@ -0,0 +1,64 @@
+import { parseAddress } from "./parseAddress";
+import { Indexer, } 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 class FundIndexer extends Indexer {
+    owners;
+    network;
+    tag = "fund";
+    name = "Funds";
+    constructor(owners = new Set(), network = "mainnet") {
+        super(owners, network);
+        this.owners = owners;
+        this.network = network;
+    }
+    async parse(txo) {
+        const script = txo.output.lockingScript;
+        const satoshis = BigInt(txo.output.satoshis || 0);
+        const address = parseAddress(script, 0, this.network);
+        if (satoshis < 2n)
+            return;
+        return {
+            data: address,
+            tags: [],
+            owner: address,
+            basket: "fund",
+        };
+    }
+    async summarize(ctx) {
+        let satsOut = 0n;
+        let satsIn = 0n;
+        // Calculate satoshis spent from our addresses (inputs)
+        for (const input of ctx.tx.inputs) {
+            if (!input.sourceTransaction) {
+                // If we don't have source transaction data, we can't determine balance change
+                return;
+            }
+            const sourceOutput = input.sourceTransaction.outputs[input.sourceOutputIndex];
+            const address = parseAddress(sourceOutput.lockingScript, 0, this.network);
+            if (this.owners.has(address)) {
+                satsOut += BigInt(sourceOutput.satoshis || 0);
+            }
+        }
+        // Calculate satoshis received to our addresses (outputs)
+        satsIn = ctx.txos.reduce((acc, txo) => {
+            if (!txo.data[this.tag])
+                return acc;
+            const satoshis = BigInt(txo.output.satoshis || 0);
+            return acc + (txo.owner && this.owners.has(txo.owner) ? satoshis : 0n);
+        }, 0n);
+        const balance = Number(satsIn - satsOut);
+        if (balance) {
+            return {
+                amount: balance,
+            };
+        }
+    }
+}

package/dist/indexers/InscriptionIndexer.js

@@ -0,0 +1,115 @@
+import { Inscription as InscriptionTemplate } from "@bopen-io/ts-templates";
+import { OP, Script, Utils } from "@bsv/sdk";
+import { MapIndexer } from "./MapIndexer";
+import { parseAddress } from "./parseAddress";
+import { Indexer, } from "./types";
+/**
+ * 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 class InscriptionIndexer extends Indexer {
+    owners;
+    network;
+    tag = "insc";
+    name = "Inscriptions";
+    constructor(owners = new Set(), network = "mainnet") {
+        super(owners, network);
+        this.owners = owners;
+        this.network = network;
+    }
+    async parse(txo) {
+        const satoshis = BigInt(txo.output.satoshis || 0);
+        if (satoshis !== 1n)
+            return;
+        const script = txo.output.lockingScript;
+        // Use template decode
+        const decoded = InscriptionTemplate.decode(script);
+        if (!decoded)
+            return;
+        // Extract owner from script prefix or suffix
+        let owner = parseAddress(script, 0, this.network);
+        if (!owner && decoded.scriptSuffix) {
+            // Try to find owner in suffix (after OP_ENDIF)
+            const suffixScript = Script.fromBinary(Array.from(decoded.scriptSuffix));
+            owner = parseAddress(suffixScript, 0, this.network);
+            // Also check for OP_CODESEPARATOR pattern
+            if (!owner && suffixScript.chunks[0]?.op === OP.OP_CODESEPARATOR) {
+                owner = parseAddress(suffixScript, 1, this.network);
+            }
+        }
+        // Handle MAP field if present (special case)
+        // Note: This writes to txo.data.map directly as a side effect
+        if (decoded.fields?.has("MAP")) {
+            const mapData = decoded.fields.get("MAP");
+            if (mapData) {
+                const map = MapIndexer.parseMap(Script.fromBinary(Array.from(mapData)), 0);
+                if (map) {
+                    txo.data.map = { data: map, tags: [] };
+                }
+            }
+        }
+        // Convert to wallet-toolbox format
+        const insc = {
+            file: {
+                hash: Utils.toBase64(Array.from(decoded.file.hash)),
+                size: decoded.file.size,
+                type: decoded.file.type,
+                content: Array.from(decoded.file.content),
+            },
+            fields: {},
+        };
+        // Extract text content if it's a text-based inscription and small enough
+        let content;
+        const contentType = decoded.file.type.toLowerCase();
+        const isTextContent = contentType.startsWith("text/") || contentType === "application/json";
+        if (isTextContent && decoded.file.size <= 1000) {
+            try {
+                content = new TextDecoder().decode(decoded.file.content);
+            }
+            catch {
+                // Ignore decoding errors
+            }
+        }
+        // Convert parent outpoint to string format
+        if (decoded.parent) {
+            try {
+                const reader = new Utils.Reader(Array.from(decoded.parent));
+                const txid = Utils.toHex(reader.read(32).reverse());
+                const vout = reader.readInt32LE();
+                insc.parent = `${txid}_${vout}`;
+            }
+            catch {
+                // Ignore parsing errors
+            }
+        }
+        // Convert fields to base64 strings
+        if (decoded.fields && insc.fields) {
+            for (const [key, value] of decoded.fields) {
+                if (key !== "MAP") {
+                    insc.fields[key] = Buffer.from(value).toString("base64");
+                }
+            }
+        }
+        return {
+            data: insc,
+            tags: [],
+            owner,
+            content,
+        };
+    }
+    async summarize(ctx) {
+        // Clear file content before saving - content is loaded locally but shouldn't be persisted
+        for (const txo of ctx.txos) {
+            const insc = txo.data[this.tag]?.data;
+            if (insc?.file) {
+                insc.file.content = [];
+            }
+        }
+        return undefined;
+    }
+}

package/dist/indexers/LockIndexer.js

@@ -0,0 +1,42 @@
+import { Lock } from "@bopen-io/ts-templates";
+import { Indexer, } from "./types";
+export class LockIndexer extends Indexer {
+    tag = "lock";
+    name = "Locks";
+    async parse(txo) {
+        const lockingScript = txo.output.lockingScript;
+        const decoded = Lock.decode(lockingScript, this.network === "mainnet");
+        if (!decoded)
+            return;
+        const tags = [];
+        if (this.owners.has(decoded.address)) {
+            tags.push(`lock:until:${decoded.until}`);
+        }
+        return {
+            data: { until: decoded.until },
+            tags,
+            owner: decoded.address,
+            basket: "lock",
+        };
+    }
+    async summarize(ctx) {
+        let locksOut = 0n;
+        for (const spend of ctx.spends) {
+            if (spend.data[this.tag]) {
+                const satoshis = BigInt(spend.output.satoshis || 0);
+                locksOut += spend.owner && this.owners.has(spend.owner) ? satoshis : 0n;
+            }
+        }
+        let locksIn = 0n;
+        for (const txo of ctx.txos) {
+            if (txo.data[this.tag]) {
+                const satoshis = BigInt(txo.output.satoshis || 0);
+                locksIn += txo.owner && this.owners.has(txo.owner) ? satoshis : 0n;
+            }
+        }
+        const balance = Number(locksIn - locksOut);
+        if (balance) {
+            return { amount: balance };
+        }
+    }
+}

package/dist/indexers/MapIndexer.js

@@ -0,0 +1,62 @@
+import { MAP_PREFIX } from "@bopen-io/ts-templates";
+import { OP, Script, Utils } from "@bsv/sdk";
+import { Indexer } from "./types";
+export class MapIndexer extends Indexer {
+    owners;
+    network;
+    tag = "map";
+    name = "MAP";
+    constructor(owners = new Set(), network = "mainnet") {
+        super(owners, network);
+        this.owners = owners;
+        this.network = network;
+    }
+    async parse(txo) {
+        const script = txo.output.lockingScript;
+        const retPos = script.chunks.findIndex((chunk) => chunk.op === OP.OP_RETURN);
+        if (retPos < 0 || !script.chunks[retPos]?.data?.length) {
+            return;
+        }
+        let chunks = Script.fromBinary(script.chunks[retPos].data).chunks;
+        while (chunks.length) {
+            if (Utils.toUTF8(chunks[0]?.data || []) === MAP_PREFIX) {
+                const map = MapIndexer.parseMap(new Script(chunks), 1);
+                const name = (map?.name ?? map?.subTypeData?.name ?? 'Unknown');
+                const tags = name ? [`name:${name}`] : [];
+                return map ? { data: map, tags } : undefined;
+            }
+            const pipePos = chunks.findIndex((chunk) => chunk.data?.length === 1 && chunk.data[0] !== 0x7c);
+            if (pipePos > -1) {
+                chunks = chunks.slice(pipePos + 1);
+            }
+            else
+                break;
+        }
+    }
+    static parseMap(script, mapPos) {
+        if (Utils.toUTF8(script.chunks[mapPos]?.data || []) !== "SET") {
+            return;
+        }
+        const map = {};
+        for (let i = mapPos + 1; i < script.chunks.length; i += 2) {
+            const chunk = script.chunks[i];
+            if (chunk.op === OP.OP_RETURN ||
+                (chunk.data?.length === 1 && chunk.data[0] !== 0x7c)) {
+                break;
+            }
+            const key = Utils.toUTF8(chunk.data || []);
+            const value = Utils.toUTF8(script.chunks[i + 1]?.data || []);
+            if (key === "subTypeData") {
+                try {
+                    map[key] = JSON.parse(value);
+                    continue;
+                }
+                catch {
+                    // If JSON parsing fails, fall through to store as string
+                }
+            }
+            map[key] = value;
+        }
+        return map;
+    }
+}

package/dist/indexers/OpNSIndexer.js

@@ -0,0 +1,38 @@
+import { Utils } from "@bsv/sdk";
+import { Indexer } from "./types";
+export class OpNSIndexer extends Indexer {
+    owners;
+    network;
+    tag = "opns";
+    name = "OpNS";
+    constructor(owners = new Set(), network = "mainnet") {
+        super(owners, network);
+        this.owners = owners;
+        this.network = network;
+    }
+    async parse(txo) {
+        const insc = txo.data.insc?.data;
+        if (insc?.file?.type !== "application/op-ns")
+            return;
+        const tags = [];
+        // Extract name from inscription content
+        if (insc.file?.content && txo.owner && this.owners.has(txo.owner)) {
+            try {
+                const content = Utils.toUTF8(insc.file.content);
+                const data = JSON.parse(content);
+                if (data.name) {
+                    tags.push(`name:${data.name}`);
+                }
+            }
+            catch {
+                // Invalid JSON or missing name field
+            }
+        }
+        // TODO: Add validation against OpNS server (infrastructure not ready yet)
+        return {
+            data: insc,
+            tags,
+            basket: "opns",
+        };
+    }
+}

package/dist/indexers/OrdLockIndexer.js

@@ -0,0 +1,63 @@
+import { OrdLock } from "@bopen-io/ts-templates";
+import { Indexer, } from "./types";
+export class Listing {
+    payout;
+    price;
+    constructor(payout = [], price = 0n) {
+        this.payout = payout;
+        this.price = price;
+    }
+}
+export class OrdLockIndexer extends Indexer {
+    owners;
+    network;
+    tag = "list";
+    name = "Listings";
+    constructor(owners = new Set(), network = "mainnet") {
+        super(owners, network);
+        this.owners = owners;
+        this.network = network;
+    }
+    async parse(txo) {
+        const lockingScript = txo.output.lockingScript;
+        const decoded = OrdLock.decode(lockingScript, this.network === "mainnet");
+        if (!decoded)
+            return;
+        const listing = new Listing(decoded.payout, decoded.price);
+        return {
+            data: listing,
+            tags: [`list:${listing.price}`],
+            owner: decoded.seller,
+        };
+    }
+    async summarize(ctx) {
+        // Check if any input was spending a listing
+        for (const [vin, spend] of ctx.spends.entries()) {
+            if (spend.data[this.tag]) {
+                const unlockingScript = ctx.tx.inputs[vin].unlockingScript;
+                if (unlockingScript && OrdLock.isPurchase(unlockingScript)) {
+                    // Purchased via ordlock contract
+                    return { amount: 1 };
+                }
+                // Cancelled/reclaimed by owner
+                return { amount: 0 };
+            }
+        }
+        // Check if any output is creating a listing
+        for (const txo of ctx.txos) {
+            if (txo.data[this.tag]) {
+                return { amount: -1 };
+            }
+        }
+    }
+    serialize(listing) {
+        return JSON.stringify({
+            payout: listing.payout,
+            price: listing.price.toString(10),
+        });
+    }
+    deserialize(str) {
+        const obj = JSON.parse(str);
+        return new Listing(obj.payout, BigInt(obj.price));
+    }
+}