@dcasegr/amm-client 0.0.0-stage → 0.38.1

package/dist/market/view.d.ts

@@ -0,0 +1,58 @@
+/**
+ * The Swap page's market view, shaped from the instance's answers (pure):
+ * the token topics it serves, each token's pools from its lookup, each pool's
+ * marginal price, and its validator's liveness from the runtime's liveness
+ * read of the token's beacon topic (`GET <base>/.live/tm_color_<txid>_0-live`). Token
+ * metadata (symbol, decimals, icon) comes from the wallet when it holds the
+ * token's deploy output (the LP page's inventory); otherwise only the id.
+ */
+import type { PoolState } from "@dcasegr/amm-engine";
+import type { LiveAnswer, TokenTopic } from "../lib/overlay.js";
+import type { IconRef } from "../lp/inventory.js";
+export interface TokenMeta {
+    sym?: string;
+    dec?: number;
+    icon?: IconRef;
+}
+export interface ValidatorStatus {
+    identityKey: string;
+    /** The token's liveness read returned a beat from it (the instance's window; the pages keep none). */
+    live: boolean;
+    /** Present in the token's liveness read at all. */
+    seen: boolean;
+    peerId?: string;
+    at?: number;
+    ageMs?: number;
+}
+export interface PoolRow {
+    pool: PoolState;
+    /** Marginal price, sats per token (display units when `dec` is known, else per base unit). */
+    price: string;
+    priceUnit: "token" | "base unit";
+    validator: ValidatorStatus;
+}
+export interface MarketToken {
+    topic: TokenTopic;
+    meta?: TokenMeta;
+    pools: PoolRow[];
+    /** The validators live on the token (`GET <base>/.live/tm_color_<txid>_0-live`), or null when unread. */
+    live: LiveAnswer | null;
+    /** The lookup failed for this token. */
+    error?: string;
+    /** The liveness read failed for this token. */
+    liveError?: string;
+}
+export declare const PRICE_DECIMALS = 8;
+/**
+ * bsvReserve / tokenReserve, in sats per display token when `dec` is known
+ * (× 10^dec), as a decimal string with up to 8 places. Pre-fee: what an
+ * infinitesimal swap would pay.
+ */
+export declare function marginalPrice(pool: Pick<PoolState, "bsvReserve" | "tokenReserve">, dec?: number): string;
+/** sats ÷ tokens (base units) as sats per display token, 8 places; "—" when either is 0. */
+export declare function priceOf(sats: bigint, tokens: bigint, dec?: number): string;
+export declare function validatorStatus(identityKey: string, live: LiveAnswer | null): ValidatorStatus;
+/** The engine's `lastSeen` from the heartbeat map (pools whose validator was never seen keep none). */
+export declare function withLastSeen(pools: PoolState[], live: LiveAnswer | null): PoolState[];
+export declare function buildMarketView(topics: TokenTopic[], pools: Map<string, PoolState[] | Error>, liveByToken: Map<string, LiveAnswer | Error>, meta: Map<string, TokenMeta>): MarketToken[];
+export declare function shortKey(k: string): string;

package/dist/market/view.js

@@ -0,0 +1,63 @@
+import { formatAmount } from "../lp/amounts.js";
+export const PRICE_DECIMALS = 8;
+/**
+ * bsvReserve / tokenReserve, in sats per display token when `dec` is known
+ * (× 10^dec), as a decimal string with up to 8 places. Pre-fee: what an
+ * infinitesimal swap would pay.
+ */
+export function marginalPrice(pool, dec) {
+    if (pool.tokenReserve <= 0n)
+        return "—";
+    const scale = 10n ** BigInt(PRICE_DECIMALS);
+    const num = pool.bsvReserve * 10n ** BigInt(dec ?? 0) * scale;
+    return formatAmount(num / pool.tokenReserve, PRICE_DECIMALS);
+}
+/** sats ÷ tokens (base units) as sats per display token, 8 places; "—" when either is 0. */
+export function priceOf(sats, tokens, dec) {
+    if (sats <= 0n || tokens <= 0n)
+        return "—";
+    return marginalPrice({ bsvReserve: sats, tokenReserve: tokens }, dec);
+}
+export function validatorStatus(identityKey, live) {
+    const v = live?.validators.find((x) => x.identityKey === identityKey.toLowerCase());
+    if (!v)
+        return { identityKey, live: false, seen: false };
+    return { identityKey, live: v.live, seen: true, peerId: v.peerId, at: v.at, ageMs: v.ageMs };
+}
+/** The engine's `lastSeen` from the heartbeat map (pools whose validator was never seen keep none). */
+export function withLastSeen(pools, live) {
+    return pools.map((p) => {
+        const v = live?.validators.find((x) => x.identityKey === p.validatorIdentityKey.toLowerCase());
+        return v ? { ...p, lastSeen: v.at } : p;
+    });
+}
+export function buildMarketView(topics, pools, liveByToken, meta) {
+    return topics.map((topic) => {
+        const m = meta.get(topic.tokenId);
+        const answer = pools.get(topic.tokenId);
+        const read = liveByToken.get(topic.tokenId);
+        const live = read && !(read instanceof Error) ? read : null;
+        const token = { topic, pools: [], live, ...(m ? { meta: m } : {}), ...(read instanceof Error ? { liveError: read.message } : {}) };
+        if (answer instanceof Error)
+            return { ...token, error: answer.message };
+        const dec = m?.dec;
+        token.pools = (answer ?? [])
+            .map((pool) => ({
+            pool,
+            price: marginalPrice(pool, dec),
+            priceUnit: dec === undefined ? "base unit" : "token",
+            validator: validatorStatus(pool.validatorIdentityKey, live),
+        }))
+            // Cheapest tokens first (most tokens per sat).
+            .sort((a, b) => cmpPrice(a.pool, b.pool) || a.pool.outpoint.localeCompare(b.pool.outpoint));
+        return token;
+    });
+}
+function cmpPrice(a, b) {
+    const l = a.bsvReserve * b.tokenReserve;
+    const r = b.bsvReserve * a.tokenReserve;
+    return l < r ? -1 : l > r ? 1 : 0;
+}
+export function shortKey(k) {
+    return k.length > 20 ? `${k.slice(0, 10)}…${k.slice(-6)}` : k;
+}

package/dist/pool/artifact.d.ts

@@ -0,0 +1,23 @@
+import type { RunarArtifact } from "../vendor/runar/runar-sdk.js";
+/**
+ * The compiled Pool contract (pool/Pool.runar.go), as the Go compiler writes
+ * it (`compiler.ArtifactToJSON`; see README.md "pool.artifact.json"). Its
+ * `script` is byte-identical to the template in src/fixtures/pool_artifact.zig
+ * (there with its codeSepIndex slots resolved); both are written by
+ * `go run ./gen/vectors` (0.9.0).
+ *
+ * 0.13.0 (layout 2): state TokenReserve, LpPubKey, ValidatorPubKey,
+ * ValidatorIdentity, Nonce, Affirmation; methods Swap, Close (the LP's, outputs
+ * free), Rescind.
+ */
+export declare const poolArtifact: RunarArtifact;
+/** A pool's layout: 2, the only one (0.29.1: layout 1, the 0.9.0-0.12.x contract, is dropped). */
+export type PoolVersion = 2;
+export declare function artifactOf(_version: PoolVersion): RunarArtifact;
+/** Public method indices (the method selector pushed last in a call). */
+export declare const METHOD_INDEX: {
+    readonly swap: 0;
+    readonly close: 1;
+    readonly rescind: 2;
+};
+export type PoolMethod = keyof typeof METHOD_INDEX;

package/dist/pool/artifact.js

@@ -0,0 +1,38 @@
+import poolArtifactJson from "./pool.artifact.json" with { type: "json" };
+/**
+ * The compiled Pool contract (pool/Pool.runar.go), as the Go compiler writes
+ * it (`compiler.ArtifactToJSON`; see README.md "pool.artifact.json"). Its
+ * `script` is byte-identical to the template in src/fixtures/pool_artifact.zig
+ * (there with its codeSepIndex slots resolved); both are written by
+ * `go run ./gen/vectors` (0.9.0).
+ *
+ * 0.13.0 (layout 2): state TokenReserve, LpPubKey, ValidatorPubKey,
+ * ValidatorIdentity, Nonce, Affirmation; methods Swap, Close (the LP's, outputs
+ * free), Rescind.
+ */
+export const poolArtifact = resolveCodeSepSlots(poolArtifactJson);
+/**
+ * The artifact with its codeSepIndex slots resolved in `script` (layout 2: its variable-length
+ * state makes each method push its OP_CODESEPARATOR's index). The separator is the code's
+ * byte 1, before every constructor slot, so each slot is OP_1 in every pool — as gen/vectors
+ * resolves them for src/pool.zig. runar-sdk's matcher (`matchesArtifact`,
+ * `extractConstructorArgs`) knows only constructor slots; its builder overwrites the resolved
+ * byte with the same OP_1.
+ */
+function resolveCodeSepSlots(a) {
+    const slots = a.codeSepIndexSlots ?? [];
+    if (slots.length === 0)
+        return a;
+    let script = a.script;
+    for (const s of slots) {
+        if (s.codeSepIndex !== 1 || script.slice(s.byteOffset * 2, s.byteOffset * 2 + 2) !== "00")
+            throw new Error("pool artifact: a codeSepIndex slot not at byte 1");
+        script = script.slice(0, s.byteOffset * 2) + "51" + script.slice(s.byteOffset * 2 + 2);
+    }
+    return { ...a, script };
+}
+export function artifactOf(_version) {
+    return poolArtifact;
+}
+/** Public method indices (the method selector pushed last in a call). */
+export const METHOD_INDEX = { swap: 0, close: 1, rescind: 2 };

package/dist/pool/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The AMM Pool script template (pool/Pool.runar.go) over runar-sdk, vendored in
+ * src/vendor/runar (README.md, "runar-sdk, vendored").
+ * Independent of React.
+ */
+export { PoolTemplate, PoolBuildError, RESCINDED_KEY, p2pkhUnlock, type Pool, type PoolArgs, type PoolFields, type PoolUtxo, type BuilderInput, type FeeSpec, type SwapParams, type SwapExpectation, type SwapAmounts, type SwapPlanParams, type CallPlan, type CloseParams, type PoolCall, type PoolSigner, type SigSlot, type PoolBuildErrorCode, } from "./template.js";
+export { poolArtifact, artifactOf, METHOD_INDEX, type PoolMethod, type PoolVersion } from "./artifact.js";
+export { decodeOneColor, oneColorValuePrefix, type OneColorPrefix, type OneColorRole } from "./oneColor.js";

package/dist/pool/index.js

@@ -0,0 +1,8 @@
+/**
+ * The AMM Pool script template (pool/Pool.runar.go) over runar-sdk, vendored in
+ * src/vendor/runar (README.md, "runar-sdk, vendored").
+ * Independent of React.
+ */
+export { PoolTemplate, PoolBuildError, RESCINDED_KEY, p2pkhUnlock, } from "./template.js";
+export { poolArtifact, artifactOf, METHOD_INDEX } from "./artifact.js";
+export { decodeOneColor, oneColorValuePrefix } from "./oneColor.js";

package/dist/pool/oneColor.d.ts

@@ -0,0 +1,19 @@
+import { ONE_COLOR_MAX_AMOUNT, type OneColorRole } from "@1sat/templates";
+export { ONE_COLOR_MAX_AMOUNT, type OneColorRole };
+export interface OneColorPrefix {
+    role: OneColorRole;
+    /** Wire id bytes (32, or 36 for a legacy BRC-161 id), absent on a deploy. */
+    idBytes?: Uint8Array;
+    amount: bigint;
+    payload?: Uint8Array;
+    /** Byte length of the prefix (and payload), i.e. where the inner lock starts. */
+    length: number;
+}
+/** The 1Color prefix at the start of `script`, or null when it has none (`OneColor.decode`). */
+export declare function decodeOneColor(script: Uint8Array | number[]): OneColorPrefix | null;
+/**
+ * The value-output prefix `<push id> <push amount> OP_2DROP` with no payload,
+ * as pool/Pool.runar.go's `tokenPrefix` writes it (`OneColor.value(...).prefix()`).
+ * The pool's asset id is always the 32-byte form.
+ */
+export declare function oneColorValuePrefix(idBytes: Uint8Array | number[], amount: bigint): number[];

package/dist/pool/oneColor.js

@@ -0,0 +1,39 @@
+/**
+ * BRC-162 (1Color) prefix for the pool template, over 1sat-sdk's `OneColor`
+ * (`@1sat/templates` 0.1.0, the template formerly `Mandala`). One decoder:
+ * this file only adapts `OneColor.decode` / `OneColor.value(...).prefix()` to
+ * the byte-array shape `template.ts` works in.
+ *
+ *   <push id | OP_0> <push amount | OP_0> OP_2DROP [<push payload> OP_DROP] <lock>
+ */
+import { LockingScript, Script } from "@bsv/sdk";
+import { OneColor, ONE_COLOR_MAX_AMOUNT } from "@1sat/templates";
+export { ONE_COLOR_MAX_AMOUNT };
+/** The 1Color prefix at the start of `script`, or null when it has none (`OneColor.decode`). */
+export function decodeOneColor(script) {
+    const bytes = Array.from(script);
+    const t = OneColor.decode(Script.fromBinary(bytes));
+    if (!t)
+        return null;
+    return {
+        role: t.role,
+        idBytes: t.idBytes,
+        amount: t.amount,
+        payload: t.payload,
+        length: bytes.length - t.lock.toBinary().length,
+    };
+}
+/**
+ * The value-output prefix `<push id> <push amount> OP_2DROP` with no payload,
+ * as pool/Pool.runar.go's `tokenPrefix` writes it (`OneColor.value(...).prefix()`).
+ * The pool's asset id is always the 32-byte form.
+ */
+export function oneColorValuePrefix(idBytes, amount) {
+    const id = Uint8Array.from(idBytes);
+    if (id.length !== 32)
+        throw new Error(`oneColorValuePrefix: the id must be 32 bytes, got ${id.length}`);
+    if (amount <= 0n || amount > ONE_COLOR_MAX_AMOUNT) {
+        throw new Error("oneColorValuePrefix: amount must be between 1 and 2^64-1");
+    }
+    return OneColor.value(id, amount, { lock: new LockingScript() }).prefix().toBinary();
+}