@dcasegr/amm-client 0.0.0-stage → 0.38.2

package/dist/lib/tokenId.js

@@ -0,0 +1,121 @@
+/**
+ * Token ids and outpoints, written and read in one place (skein-amm 0.6.3,
+ * 0.7.1).
+ *
+ * A token id is written `<txid>_<vout>` for every token, 1Color (BRC-162
+ * binary) and legacy BSV-21 (BRC-161 JSON) alike, `_0` included: BRC-162
+ * "Token identification" ("For display and APIs, the string form is
+ * `<txid>_<vout>` ... fixed for BSV-21 and Mandala ... for a 32-byte id,
+ * appends `_0`"). David, 2026-10-07 (shruggr/skein#120; supersedes 0.6.3's
+ * bare txid). The bare 32-byte txid is the wire form only.
+ * On input every form names the same token: `<txid>`, `<txid>_<vout>`,
+ * `<txid>.<vout>` (no vout = vout 0).
+ *
+ * An outpoint is shown `<txid>.<vout>`. David, 2026-10-08: "Outpoints are
+ * always to be shown in the txid.vout format, not underscores. The ONLY
+ * remnant of underscores is for legacy tokenIds".
+ *
+ * The wallet's BRC-207 module's asset id, 1sat-sdk's `OneColor` string id and
+ * the exchange's own filings take the same `<txid>_<vout>` (`sdkTokenId`); the
+ * module's baskets name it by its asset tag, `p color <txid>v<vout>`
+ * (src/wallet/color.ts); the Zig programs' outpoint fields
+ * (amm-lookup's `{outpoint}`, the relay's) and the LP key derivations keep
+ * `<txid>_<vout>` as before.
+ */
+const FORM = /^([0-9a-fA-F]{64})(?:[._](\d+))?$/;
+function parse(text, needVout) {
+    const m = FORM.exec(text.trim());
+    if (!m || (needVout && m[2] === undefined))
+        return null;
+    const vout = m[2] === undefined ? 0 : Number(m[2]);
+    if (!Number.isSafeInteger(vout) || vout > 0xffffffff)
+        return null;
+    return { txid: m[1].toLowerCase(), vout };
+}
+/** Any token id form (`<txid>`, `<txid>_<vout>`, `<txid>.<vout>`) → its deploy outpoint; null for anything else. */
+export function parseTokenId(text) {
+    return parse(text, false);
+}
+/** An outpoint (`<txid>.<vout>` or `<txid>_<vout>`) → txid and vout; null for anything else. */
+export function parseOutpoint(text) {
+    return parse(text, true);
+}
+/**
+ * A BRC-207 query for outpoints of token `tokenId` at a token instance (0.20.1): service
+ * `ls_color_<assetId>`, topic `tm_color_<assetId>`, exactly BRC-207's shape. A token instance
+ * serves no `ls_color`.
+ */
+export function colorQuery(type, tokenId, outpoints) {
+    const ref = parseTokenId(tokenId);
+    if (!ref)
+        throw new Error(`not a token id: ${tokenId}`);
+    const assetId = tokenIdText(ref);
+    return { service: `ls_color_${assetId}`, query: { type, version: 1, assetId, topic: `tm_color_${assetId}`, outpoints: outpoints.map(outpointText) } };
+}
+/** The discovery lookup (0.20.0): `ls_color`, color-lookup over the discovery topic `tm_color`. */
+export const DISCOVERY_LOOKUP = "ls_color";
+/**
+ * A token's deploy asked of the discovery lookup (0.20.1; David, 2026-10-29: BRC-207's form):
+ * `{service: "ls_color", query: {type: "color-admission", version: 1, assetId: "<txid>_<vout>",
+ * topic: "tm_color", outpoints: ["<txid>.<vout>"]}}` — the token id IS the deploy's outpoint.
+ */
+export function deployQuery(tokenId) {
+    const ref = parseTokenId(tokenId);
+    if (!ref)
+        throw new Error(`not a token id: ${tokenId}`);
+    return { service: DISCOVERY_LOOKUP, query: { type: "color-admission", version: 1, assetId: tokenIdText(ref), topic: "tm_color", outpoints: [`${ref.txid}.${ref.vout}`] } };
+}
+/** The token id of a deploy outpoint: `<txid>_<vout>`, `_0` included (BRC-162 "Token identification"). */
+export function tokenIdText(ref) {
+    return `${ref.txid.toLowerCase()}_${ref.vout}`;
+}
+/**
+ * The token id a 1Color output names by its BRC-162 wire id (internal byte
+ * order): 32 bytes is `<txid>_0`, 36 bytes (a legacy BRC-161 token at
+ * vout > 0) `<txid>_<vout>`; as 1sat-sdk's `OneColor` prints it.
+ */
+export function tokenIdOfWire(idBytes) {
+    const b = Uint8Array.from(idBytes);
+    if (b.length !== 32 && b.length !== 36)
+        throw new Error(`a token's wire id is 32 or 36 bytes, not ${b.length}`);
+    const txid = Array.from(b.subarray(0, 32))
+        .reverse()
+        .map((x) => x.toString(16).padStart(2, "0"))
+        .join("");
+    const vout = b.length === 32 ? 0 : new DataView(b.buffer, b.byteOffset + 32, 4).getUint32(0, true);
+    return tokenIdText({ txid, vout });
+}
+function must(text) {
+    const r = parseTokenId(text);
+    if (!r)
+        throw new Error(`not a token id (<txid>, <txid>_<vout> or <txid>.<vout>): ${text}`);
+    return r;
+}
+/** Any token id form → the token id string, `<txid>_<vout>` (a `<txid>` as `<txid>_0`): the form shown and the BRC-207 asset id (the module's receipts, `OneColor`'s string id). */
+export function sdkTokenId(text) {
+    return tokenIdText(must(text));
+}
+/** Whether two token id strings, in any form, name the same token. */
+export function sameToken(a, b) {
+    const x = parseTokenId(a);
+    const y = parseTokenId(b);
+    return !!x && !!y && x.txid === y.txid && x.vout === y.vout;
+}
+/** An outpoint for display: `<txid>.<vout>`; anything that is not an outpoint as given. */
+export function outpointText(op) {
+    const r = parseOutpoint(op);
+    return r ? `${r.txid}.${r.vout}` : op;
+}
+const shortTxid = (txid) => `${txid.slice(0, 8)}…${txid.slice(-8)}`;
+/** An outpoint shortened for display (the txid to its first and last 8, as skein-1color 0.7.4 shows ids): `abcdef01…456789ab.0`. */
+export function shortOutpoint(op) {
+    const r = parseOutpoint(op);
+    return r ? `${shortTxid(r.txid)}.${r.vout}` : op;
+}
+/** A token id shortened for display, in the form it is written: `abcdef01…456789ab_0`; a bare txid (not a token id) as `abcdef01…456789ab`. */
+export function shortTokenId(id) {
+    const m = FORM.exec(id);
+    if (!m)
+        return id;
+    return m[2] === undefined ? shortTxid(m[1].toLowerCase()) : `${shortTxid(m[1].toLowerCase())}_${m[2]}`;
+}

package/dist/lp/amounts.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Token amounts are integers in base units; `dec` places shift them for display
+ * (BRC-162 `dec`, 0-18). Pure string arithmetic on bigints, no floats.
+ */
+export declare const MAX_DECIMALS = 18;
+/** `amount` base units as a decimal string with `dec` places, trailing zeros trimmed. */
+export declare function formatAmount(amount: bigint, dec?: number): string;
+/**
+ * A decimal string entered in display units → base units. Throws on anything
+ * that is not a non-negative number with at most `dec` fractional digits.
+ */
+export declare function parseAmount(text: string, dec?: number): bigint;

package/dist/lp/amounts.js

@@ -0,0 +1,38 @@
+/**
+ * Token amounts are integers in base units; `dec` places shift them for display
+ * (BRC-162 `dec`, 0-18). Pure string arithmetic on bigints, no floats.
+ */
+export const MAX_DECIMALS = 18;
+function checkDec(dec) {
+    if (!Number.isInteger(dec) || dec < 0 || dec > MAX_DECIMALS) {
+        throw new Error(`decimals must be an integer 0-${MAX_DECIMALS}`);
+    }
+}
+/** `amount` base units as a decimal string with `dec` places, trailing zeros trimmed. */
+export function formatAmount(amount, dec = 0) {
+    checkDec(dec);
+    const neg = amount < 0n;
+    const digits = (neg ? -amount : amount).toString();
+    if (dec === 0)
+        return (neg ? "-" : "") + digits;
+    const padded = digits.padStart(dec + 1, "0");
+    const whole = padded.slice(0, padded.length - dec);
+    const frac = padded.slice(padded.length - dec).replace(/0+$/, "");
+    return (neg ? "-" : "") + whole + (frac ? `.${frac}` : "");
+}
+/**
+ * A decimal string entered in display units → base units. Throws on anything
+ * that is not a non-negative number with at most `dec` fractional digits.
+ */
+export function parseAmount(text, dec = 0) {
+    checkDec(dec);
+    const s = text.trim().replace(/_/g, "");
+    const m = /^(\d*)(?:\.(\d*))?$/.exec(s);
+    if (!m || (m[1] === "" && (m[2] ?? "") === ""))
+        throw new Error(`not an amount: "${text}"`);
+    const whole = m[1] || "0";
+    const frac = m[2] ?? "";
+    if (frac.length > dec)
+        throw new Error(`at most ${dec} decimal place(s)`);
+    return BigInt(whole + frac.padEnd(dec, "0"));
+}

package/dist/lp/close.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Close through the user's wallet: the LP's alone, so nothing is relayed (`Close(lpSig)`,
+ * outputs free; skein-amm 0.13.0). One path (0.29.0, David Case 2026-11-02: "we should just use
+ * create action directly"; 0.29.1: the page-built close and layout 1 gone; 0.29.3: a module plan):
+ *
+ *   1. The pool's current output and its BEEF: 0.34.0, `GET /@<token>/amm/pools/beef?lp=<its LP
+ *      key>` (the pool's current output by its LP key, live or rescinded).
+ *   2. The LP's one output (`PoolTemplate.planClose`): every token, one sat, to a NEW module
+ *      receiving key of the user's own (`newReceivingKey`, sender the user's identity). The pool's
+ *      sats go to the wallet's change: no payout output, no remittance.
+ *   3. ONE createAction through the wallet's BRC-207 module: a `p color plan` transfer whose owned
+ *      output 0 is that token output (the module checks it pays the remittance's key and files it
+ *      in `p color <assetTag>` with its custody in this same call); the pool an explicit input
+ *      (its BEEF the lookup's, `unlockingScriptLength` `PoolTemplate.maxCallUnlockLength`) — to the
+ *      module a FOREIGN token input, checked admitted and unspent on the token's overlay;
+ *      `randomizeOutputs: false`. The wallet pays the miner fee and the token output's sat, its
+ *      change takes the pool's sats; the page fills the pool input over the wallet's transaction
+ *      (`callUnlock` + the LP's `createSignature`, checked with `Spend`) at signAction; the
+ *      module approves and submits, the wallet broadcasts and marks the pool row spent.
+ *   4. `POST <origin>/submit` (`x-topics: tm_color_<assetId>`), the close's AtomicBEEF: the page's
+ *      own submit. Nothing is taken in afterwards and nothing is kept in the browser.
+ */
+import { Transaction, type WalletInterface } from "@bsv/sdk";
+import { type CallPlan } from "../pool/index.js";
+import type { LookupOutput } from "../lib/overlay.js";
+import type { LpKeyRef } from "./positions.js";
+export declare class CloseShapeError extends Error {
+    constructor(message: string);
+}
+export interface CloseInput {
+    wallet: WalletInterface;
+    /** `<txid>_0` (src/lib/tokenId.ts). */
+    tokenId: string;
+    meta?: {
+        sym?: string;
+        dec?: number;
+    };
+    /** The pool's current output (step 1). */
+    poolOutput: LookupOutput;
+    lpKey: LpKeyRef;
+}
+export interface PreparedClose {
+    plan: CallPlan;
+    /** The pool output spent, `txid.vout`. */
+    poolOutpoint: string;
+    /** Every input signed (the wallet's transaction). */
+    tx: Transaction;
+    txid: string;
+    /** The close's AtomicBEEF: the `/submit` body. */
+    beef: number[];
+    /** `tm_color_<assetId>` */
+    topic: string;
+    /** The token output (0), filed by the module. */
+    tokenOutput: {
+        outputIndex: number;
+        lockingScript: string;
+    };
+    /** What returns to the wallet: the pool's sats (into its change, less the fee) and its tokens. */
+    sats: bigint;
+    tokenAmount: bigint;
+}
+/** Steps 2-3 (see the module comment): the wallet's action, broadcast by the wallet. */
+export declare function prepareClose(i: CloseInput): Promise<PreparedClose>;
+/** The `x-topics` header of a BRC-22 submit (D14): the topics as a JSON array, `["tm_color_<assetId>"]`. */
+export declare function xTopics(topics: string[]): string;
+/** BRC-22's STEAK: per topic, the outputs admitted and the coins retained and removed. */
+export type Steak = Record<string, {
+    outputsToAdmit: number[];
+    coinsToRetain: number[];
+    coinsRemoved: number[];
+}>;
+/**
+ * Submit to the exchange (BRC-22; skein-overlay 0.9.1, docs/OVERLAY.md "Submitting"): 0.34.0 (D19,
+ * David Case 2026-11-04): `POST <origin>/submit` at the HOST ROOT of `base` (`x-topics` the token
+ * topic, which the host routes to the instance serving it; the body the BEEF) — no token list read
+ * for an instance base — waits on the submission and
+ * answers the STEAK; 503 with Retry-After when nothing is decided within the host's bound (the
+ * submission stands: `steak` absent). Plain `fetch`, unsigned (0.6.3; David 2026-10-08: "We
+ * shouldn't be using authfetch for the submit http method."): the front door (shruggr/skein#135)
+ * admits an unsigned POST at the overlay's `submit` row (sender `*`, filter `beef`), and
+ * `@bsv/sdk`'s AuthFetch refuses the `x-topics` header client-side. 0.38.0 (D14): `x-topics` is
+ * the BRC-22 JSON array (`xTopics`), the one form the client sends (the host takes a comma list too).
+ */
+export declare function submitToOverlay(base: string, topic: string, beef: number[], fetchFn?: (url: string, init: RequestInit) => Promise<Response>): Promise<{
+    steak?: Steak;
+}>;
+/** The STEAK in words: the topics that admitted outputs, else "taken by no topic"; no STEAK, "not decided yet". */
+export declare function steakText(r: {
+    steak?: Steak;
+}): string;

package/dist/lp/close.js

@@ -0,0 +1,140 @@
+/**
+ * Close through the user's wallet: the LP's alone, so nothing is relayed (`Close(lpSig)`,
+ * outputs free; skein-amm 0.13.0). One path (0.29.0, David Case 2026-11-02: "we should just use
+ * create action directly"; 0.29.1: the page-built close and layout 1 gone; 0.29.3: a module plan):
+ *
+ *   1. The pool's current output and its BEEF: 0.34.0, `GET /@<token>/amm/pools/beef?lp=<its LP
+ *      key>` (the pool's current output by its LP key, live or rescinded).
+ *   2. The LP's one output (`PoolTemplate.planClose`): every token, one sat, to a NEW module
+ *      receiving key of the user's own (`newReceivingKey`, sender the user's identity). The pool's
+ *      sats go to the wallet's change: no payout output, no remittance.
+ *   3. ONE createAction through the wallet's BRC-207 module: a `p color plan` transfer whose owned
+ *      output 0 is that token output (the module checks it pays the remittance's key and files it
+ *      in `p color <assetTag>` with its custody in this same call); the pool an explicit input
+ *      (its BEEF the lookup's, `unlockingScriptLength` `PoolTemplate.maxCallUnlockLength`) — to the
+ *      module a FOREIGN token input, checked admitted and unspent on the token's overlay;
+ *      `randomizeOutputs: false`. The wallet pays the miner fee and the token output's sat, its
+ *      change takes the pool's sats; the page fills the pool input over the wallet's transaction
+ *      (`callUnlock` + the LP's `createSignature`, checked with `Spend`) at signAction; the
+ *      module approves and submits, the wallet broadcasts and marks the pool row spent.
+ *   4. `POST <origin>/submit` (`x-topics: tm_color_<assetId>`), the close's AtomicBEEF: the page's
+ *      own submit. Nothing is taken in afterwards and nothing is kept in the browser.
+ */
+import { Beef, PublicKey, Transaction } from "@bsv/sdk";
+import { PoolTemplate } from "../pool/index.js";
+import { poolUtxoFrom, spendValid } from "../market/swapAction.js";
+import { identityKeyOf, isBrc29Protocol } from "../wallet/brc29.js";
+import { sdkTokenId } from "../lib/tokenId.js";
+import { newReceivingKey, transferPlanLabels } from "../wallet/color.js";
+import { inputIndexOf, runAppSignedAction } from "../wallet/action.js";
+import { tokenP2pkhScript } from "./poolDeploy.js";
+export class CloseShapeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "CloseShapeError";
+    }
+}
+/** BRC-100 descriptions are 5-50 characters. */
+function describe(text) {
+    return text.length <= 50 ? text : `${text.slice(0, 49)}…`;
+}
+/** Steps 2-3 (see the module comment): the wallet's action, broadcast by the wallet. */
+export async function prepareClose(i) {
+    const { wallet } = i;
+    const poolUtxo = poolUtxoFrom(i.poolOutput);
+    const pool = PoolTemplate.decode(poolUtxo.script);
+    if (!pool)
+        throw new CloseShapeError("the output is not a pool");
+    if (!isBrc29Protocol(i.lpKey.protocolID) || i.lpKey.counterparty !== "self")
+        throw new CloseShapeError(`the LP key ${i.lpKey.keyID} is not a BRC-29 key to self`);
+    const lpArgs = { protocolID: i.lpKey.protocolID, keyID: i.lpKey.keyID, counterparty: i.lpKey.counterparty };
+    const { publicKey: lpPub } = await wallet.getPublicKey({ ...lpArgs, forSelf: true });
+    if (PublicKey.fromString(lpPub).toString() !== pool.state.lpPubKey)
+        throw new CloseShapeError(`the wallet key ${i.lpKey.keyID} is not this pool's LP key`);
+    const sdkId = sdkTokenId(i.tokenId);
+    const sym = i.meta?.sym ?? "token";
+    const me = await identityKeyOf(wallet);
+    const k = await newReceivingKey(wallet, sdkId, me);
+    const tokenScript = tokenP2pkhScript(sdkId, pool.state.tokenReserve, k.publicKey);
+    const plan = PoolTemplate.planClose({ pool: poolUtxo, outputs: [{ satoshis: 1n, script: tokenScript }] });
+    const poolOutpoint = `${poolUtxo.txid}.${poolUtxo.vout}`;
+    const lpSigner = async (sighash) => (await wallet.createSignature({ ...lpArgs, hashToDirectlySign: sighash })).signature;
+    const signed = await runAppSignedAction(wallet, {
+        description: describe(`AMM close: ${sym}`),
+        inputBEEF: Beef.fromBinary(i.poolOutput.beef).toBinary(),
+        inputs: [{ outpoint: poolOutpoint, unlockingScriptLength: PoolTemplate.maxCallUnlockLength(plan), inputDescription: describe(`The ${sym} pool`) }],
+        outputs: [{ lockingScript: tokenScript, satoshis: 1, outputDescription: describe(`${sym} pool tokens to you`) }],
+        labels: [...transferPlanLabels(sdkId, { ownedOutputs: [{ outputIndex: 0, ...k.receipt }] }), "amm-close"],
+        options: { randomizeOutputs: false, acceptDelayedBroadcast: false },
+    }, async (tx) => {
+        // The contract reads input 0 (the preimage is input 0's); the wallet places named inputs first.
+        if (inputIndexOf(tx, poolUtxo.txid, poolUtxo.vout) !== 0)
+            throw new CloseShapeError("the wallet did not place the pool as input 0");
+        if (tx.outputs[0]?.lockingScript.toHex() !== tokenScript || tx.outputs[0]?.satoshis !== 1)
+            throw new CloseShapeError("the wallet moved output 0 of the close");
+        // Close's outputs are free: the call's preimage covers the wallet's outputs, change included.
+        const callPlan = PoolTemplate.planClose({ pool: poolUtxo, outputs: tx.outputs.map((o) => ({ satoshis: BigInt(o.satoshis), script: o.lockingScript.toHex() })) });
+        tx.inputs[0].unlockingScript = PoolTemplate.callUnlock(callPlan, tx, null).unlockingScript;
+        await PoolTemplate.signPoolInput({ tx, pool: callPlan.pool, method: "close", unsigned: ["lp"], sourceSatoshis: poolUtxo.satoshis }, "lp", lpSigner);
+        if (!spendValid(tx, 0))
+            throw new CloseShapeError("input 0 of the close does not validate");
+        return { 0: { unlockingScript: tx.inputs[0].unlockingScript.toHex() } };
+    });
+    return {
+        plan,
+        poolOutpoint,
+        tx: Transaction.fromAtomicBEEF(signed.tx),
+        txid: signed.txid,
+        beef: signed.tx,
+        topic: `tm_color_${sdkId}`,
+        tokenOutput: { outputIndex: 0, lockingScript: tokenScript },
+        sats: BigInt(poolUtxo.satoshis),
+        tokenAmount: pool.state.tokenReserve,
+    };
+}
+/** The `x-topics` header of a BRC-22 submit (D14): the topics as a JSON array, `["tm_color_<assetId>"]`. */
+export function xTopics(topics) {
+    return JSON.stringify(topics);
+}
+/**
+ * Submit to the exchange (BRC-22; skein-overlay 0.9.1, docs/OVERLAY.md "Submitting"): 0.34.0 (D19,
+ * David Case 2026-11-04): `POST <origin>/submit` at the HOST ROOT of `base` (`x-topics` the token
+ * topic, which the host routes to the instance serving it; the body the BEEF) — no token list read
+ * for an instance base — waits on the submission and
+ * answers the STEAK; 503 with Retry-After when nothing is decided within the host's bound (the
+ * submission stands: `steak` absent). Plain `fetch`, unsigned (0.6.3; David 2026-10-08: "We
+ * shouldn't be using authfetch for the submit http method."): the front door (shruggr/skein#135)
+ * admits an unsigned POST at the overlay's `submit` row (sender `*`, filter `beef`), and
+ * `@bsv/sdk`'s AuthFetch refuses the `x-topics` header client-side. 0.38.0 (D14): `x-topics` is
+ * the BRC-22 JSON array (`xTopics`), the one form the client sends (the host takes a comma list too).
+ */
+export async function submitToOverlay(base, topic, beef, fetchFn = (url, init) => fetch(url, init)) {
+    const url = `${new URL(base).origin}/submit`;
+    const res = await fetchFn(url, {
+        method: "POST",
+        headers: { "content-type": "application/octet-stream", "x-topics": xTopics([topic]) },
+        body: new Uint8Array(beef),
+    });
+    const text = await res.text();
+    if (res.status === 503)
+        return {};
+    if (!res.ok)
+        throw new Error(`POST ${url}: ${res.status} ${text.slice(0, 300)}`);
+    let steak;
+    try {
+        steak = JSON.parse(text);
+    }
+    catch {
+        /* not JSON */
+    }
+    if (!steak || typeof steak !== "object" || Array.isArray(steak))
+        throw new Error(`POST ${url}: want the STEAK, got ${text.slice(0, 300)}`);
+    return { steak: steak };
+}
+/** The STEAK in words: the topics that admitted outputs, else "taken by no topic"; no STEAK, "not decided yet". */
+export function steakText(r) {
+    if (!r.steak)
+        return "not decided yet";
+    const took = Object.entries(r.steak).filter(([, e]) => e.outputsToAdmit.length > 0).map(([t, e]) => `${t} (outputs ${e.outputsToAdmit.join(", ")})`);
+    return took.length ? `admitted under ${took.join("; ")}` : "taken by no topic";
+}

package/dist/lp/images.d.ts

@@ -0,0 +1,11 @@
+import { Script } from "@bsv/sdk";
+export interface ImageContent {
+    contentType: string;
+    bytes: Uint8Array;
+    /** Which encoding carried it: an inscription, a B file, or embedded in a 1Color deploy's payload (BRC-162 draft BRCs#308). */
+    via: "inscription" | "b" | "embedded";
+}
+/** The image content in `script`, or undefined (no content, or not an image). */
+export declare function imageFromScript(script: Script | string | number[] | undefined): ImageContent | undefined;
+/** `data:` URL for an `<img src>`. */
+export declare function imageDataUrl(img: ImageContent): string;

package/dist/lp/images.js

@@ -0,0 +1,45 @@
+/**
+ * Image bytes held in a locking script: a 1Sat ordinal inscription (`ord`
+ * envelope, @1sat/templates `Inscription`) or a B protocol file
+ * (`OP_FALSE OP_RETURN 19Hxig… <data> <type> <encoding>`, @1sat/templates `B`).
+ */
+import { Inscription, B } from "@1sat/templates";
+import { Script, Utils } from "@bsv/sdk";
+function isImage(type) {
+    return !!type && type.split(";")[0].trim().toLowerCase().startsWith("image/");
+}
+/** The image content in `script`, or undefined (no content, or not an image). */
+export function imageFromScript(script) {
+    if (script === undefined)
+        return undefined;
+    let s;
+    try {
+        s = typeof script === "string" ? Script.fromHex(script) : Array.isArray(script) ? Script.fromBinary(script) : script;
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        const ins = Inscription.decode(s);
+        if (ins && isImage(ins.file.type) && ins.file.content.length > 0) {
+            return { contentType: ins.file.type, bytes: Uint8Array.from(ins.file.content), via: "inscription" };
+        }
+    }
+    catch {
+        /* not an inscription */
+    }
+    try {
+        const b = B.decode(s);
+        if (b && isImage(b.mediaType) && b.data.length > 0) {
+            return { contentType: b.mediaType, bytes: Uint8Array.from(b.data), via: "b" };
+        }
+    }
+    catch {
+        /* not a B file */
+    }
+    return undefined;
+}
+/** `data:` URL for an `<img src>`. */
+export function imageDataUrl(img) {
+    return `data:${img.contentType.split(";")[0].trim()};base64,${Utils.toBase64(Array.from(img.bytes))}`;
+}

package/dist/lp/inventory.d.ts

@@ -0,0 +1,68 @@
+/**
+ * The token inventory from the wallet's BRC-207 module (skein-amm 0.12.0):
+ * `p color assets`' outputs (src/wallet/color.ts `heldOutputs`), decoded
+ * from their locking scripts with 1sat-sdk's `OneColor` (BRC-162), grouped
+ * by asset id. The script is the authority for which asset an output holds;
+ * the balance the page shows is the module's own (`p color balance
+ * <assetTag>`, src/client.ts `myTokens`).
+ *
+ * Metadata (sym/dec/icon) comes from the overlay (the token list, else the
+ * deploy lookup) and, for a deploy output the wallet holds, from the deploy
+ * itself: a 1Color deploy's icon is the image embedded in it (BRC-162,
+ * BRCs#308: `[mediaType, bytes]`).
+ */
+import { type OneColorIcon } from "@1sat/templates";
+import type { ImageContent } from "./images.js";
+export type TokenRole = "deploy" | "value" | "authority";
+export interface TokenMetadata {
+    sym?: string;
+    dec?: number;
+    /** The image embedded in the deploy. */
+    icon?: OneColorIcon;
+}
+export interface TokenOutput {
+    /** `txid_vout` */
+    outpoint: string;
+    /** `<txid>_<vout>` for every token, `_0` included (src/lib/tokenId.ts). */
+    tokenId: string;
+    role: TokenRole;
+    /** Base units; 0n on an authority (or an authority deploy). */
+    amount: bigint;
+    /** Deploys only. */
+    metadata?: TokenMetadata;
+}
+export interface IconRef {
+    /** The deploy the icon is embedded in, `txid_vout`. */
+    outpoint: string;
+    /** The bytes, when the deploy embeds an image. */
+    image?: ImageContent;
+}
+export interface TokenSummary {
+    tokenId: string;
+    /** Sum of value outputs and a fixed-supply deploy, base units, as the scripts carry them. */
+    balance: bigint;
+    valueOutputs: number;
+    /** Authority outputs, an authority deploy included. */
+    authorities: number;
+    deployInWallet: boolean;
+    sym?: string;
+    dec?: number;
+    icon?: IconRef;
+}
+export interface Inventory {
+    tokens: TokenSummary[];
+    /** Outputs `OneColor` does not decode. */
+    unrecognized: string[];
+}
+/** One held output → its token output, or undefined. */
+export declare function decodeTokenRow(row: {
+    outpoint: string;
+    lockingScript?: string;
+}): TokenOutput | undefined;
+/** The icon embedded in a deploy (an image only; another media type shows no picture). */
+export declare function deployIcon(deploy: TokenOutput): IconRef | undefined;
+/** Group decoded rows by token, its id `<txid>_<vout>`. */
+export declare function buildInventory(rows: {
+    outpoint: string;
+    lockingScript?: string;
+}[]): Inventory;

package/dist/lp/inventory.js

@@ -0,0 +1,84 @@
+/**
+ * The token inventory from the wallet's BRC-207 module (skein-amm 0.12.0):
+ * `p color assets`' outputs (src/wallet/color.ts `heldOutputs`), decoded
+ * from their locking scripts with 1sat-sdk's `OneColor` (BRC-162), grouped
+ * by asset id. The script is the authority for which asset an output holds;
+ * the balance the page shows is the module's own (`p color balance
+ * <assetTag>`, src/client.ts `myTokens`).
+ *
+ * Metadata (sym/dec/icon) comes from the overlay (the token list, else the
+ * deploy lookup) and, for a deploy output the wallet holds, from the deploy
+ * itself: a 1Color deploy's icon is the image embedded in it (BRC-162,
+ * BRCs#308: `[mediaType, bytes]`).
+ */
+import { OneColor } from "@1sat/templates";
+import { Script } from "@bsv/sdk";
+import { parseOutpoint, tokenIdOfWire, tokenIdText } from "../lib/tokenId.js";
+/** One held output → its token output, or undefined. */
+export function decodeTokenRow(row) {
+    if (!row.lockingScript)
+        return undefined;
+    const op = parseOutpoint(row.outpoint);
+    if (!op)
+        return undefined;
+    const outpoint = `${op.txid}_${op.vout}`;
+    let script;
+    try {
+        script = Script.fromHex(row.lockingScript);
+    }
+    catch {
+        return undefined;
+    }
+    const bin = OneColor.decode(script);
+    if (!bin)
+        return undefined;
+    if (bin.role === "deploy")
+        return { outpoint, tokenId: tokenIdText(op), role: "deploy", amount: bin.amount, metadata: bin.metadata ?? {} };
+    // A 32-byte id is `<txid>_0`, a 36-byte one `<txid>_<vout>`.
+    return { outpoint, tokenId: tokenIdOfWire(bin.idBytes), role: bin.role, amount: bin.amount };
+}
+/** The icon embedded in a deploy (an image only; another media type shows no picture). */
+export function deployIcon(deploy) {
+    const icon = deploy.metadata?.icon;
+    if (icon === undefined)
+        return undefined;
+    if (!/^image\//i.test(icon.mediaType.trim()) || icon.bytes.length === 0)
+        return { outpoint: deploy.outpoint };
+    return { outpoint: deploy.outpoint, image: { contentType: icon.mediaType, bytes: Uint8Array.from(icon.bytes), via: "embedded" } };
+}
+/** Group decoded rows by token, its id `<txid>_<vout>`. */
+export function buildInventory(rows) {
+    const byId = new Map();
+    const unrecognized = [];
+    for (const row of rows) {
+        const t = decodeTokenRow(row);
+        if (!t) {
+            unrecognized.push(row.outpoint.replace(".", "_"));
+            continue;
+        }
+        let s = byId.get(t.tokenId);
+        if (!s) {
+            s = { tokenId: t.tokenId, balance: 0n, valueOutputs: 0, authorities: 0, deployInWallet: false };
+            byId.set(t.tokenId, s);
+        }
+        if (t.amount === 0n)
+            s.authorities++;
+        else {
+            s.balance += t.amount;
+            s.valueOutputs++;
+        }
+        if (t.role === "deploy") {
+            s.deployInWallet = true;
+            const m = t.metadata ?? {};
+            if (m.sym !== undefined)
+                s.sym = m.sym;
+            if (m.dec !== undefined)
+                s.dec = m.dec;
+            const icon = deployIcon(t);
+            if (icon)
+                s.icon = icon;
+        }
+    }
+    const tokens = [...byId.values()].sort((a, b) => (a.sym ?? "￿").localeCompare(b.sym ?? "￿") || a.tokenId.localeCompare(b.tokenId));
+    return { tokens, unrecognized };
+}