@attocash/cli 0.1.0

package/dist/doctor/profile.js

@@ -0,0 +1,73 @@
+import { accessSync, constants, existsSync, statSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { z } from 'zod';
+import { parseOperation } from '../application/operations.js';
+import { amountRaw } from '../domain/amount.js';
+import { AttoError } from '../domain/errors.js';
+import { parseAddress } from '../network/reader.js';
+import { marketTerms } from '../pricing/terms.js';
+import { defaultSettings } from '../wallet/defaults.js';
+const identitySchema = z.strictObject({ address: z.string().max(128), fingerprint: z.string().regex(/^[a-f\d]{64}$/i) });
+const addressesSchema = z.array(z.strictObject({ index: z.number().int().min(0).max(2147483647),
+    address: z.string().max(128), publicKey: z.string().regex(/^[a-f\d]{64}$/i), active: z.boolean() }));
+/** Read a consistent snapshot without StateStore's initialization, migration, or chmod. */
+export function readDoctorProfile(directory) {
+    let parent = directory;
+    while (!existsSync(parent) && dirname(parent) !== parent)
+        parent = dirname(parent);
+    accessSync(parent, constants.R_OK | constants.W_OK | constants.X_OK);
+    const file = join(directory, 'state.sqlite');
+    const directoryInfo = existsSync(directory) ? statSync(directory) : undefined;
+    const databaseInfo = existsSync(file) ? statSync(file) : undefined;
+    const permissions = process.platform !== 'win32' && directoryInfo ? {
+        private: (directoryInfo.mode & 0o077) === 0 && (!databaseInfo || (databaseInfo.mode & 0o077) === 0),
+        directoryMode: (directoryInfo.mode & 0o777).toString(8),
+        ...(databaseInfo ? { databaseMode: (databaseInfo.mode & 0o777).toString(8) } : {}),
+    } : undefined;
+    if (!databaseInfo)
+        return { settings: defaultSettings(), settingsSource: 'defaults', addresses: [], access: 'read-only', poolIndexes: [0], pendingPayments: 0, resetPending: false, termsAccepted: false, permissions };
+    accessSync(file, constants.R_OK | constants.W_OK);
+    const state = new DatabaseSync(file, { readOnly: true });
+    try {
+        state.exec('PRAGMA busy_timeout = 1000; BEGIN;');
+        if (state.prepare('PRAGMA user_version').get()?.user_version !== 1)
+            throw new AttoError('STATE_VERSION', 'This wallet state requires a supported Atto CLI version.');
+        const get = (key) => {
+            const row = state.prepare('SELECT value FROM settings WHERE key = ?').get(key);
+            if (!row)
+                return undefined;
+            if (typeof row.value !== 'string' || row.value.length > 1_048_576)
+                throw new Error('Invalid state value');
+            return JSON.parse(row.value);
+        };
+        const settings = parseOperation('wallet_configure', get('settings'));
+        if (['network', 'nodeUrl', 'workerUrl', 'representative', 'autoReceive', 'minReceiveRaw'].some(key => !Object.hasOwn(settings, key)))
+            throw new Error('Incomplete settings');
+        parseAddress(settings.representative);
+        amountRaw(settings.minReceiveRaw, 'RAW');
+        const savedIdentity = get('identity');
+        const identity = savedIdentity === undefined ? undefined : identitySchema.parse(savedIdentity);
+        if (identity)
+            parseAddress(identity.address);
+        const addresses = addressesSchema.parse(get('addresses') ?? []);
+        if (new Set(addresses.map(address => address.index)).size !== addresses.length)
+            throw new Error('Duplicate account indexes');
+        for (const address of addresses) {
+            if (parseAddress(address.address).publicKey.toString().toUpperCase() !== address.publicKey.toUpperCase())
+                throw new Error('Account identity mismatch');
+        }
+        if (identity && addresses.find(address => address.index === 0)?.address !== identity.address)
+            throw new Error('Wallet identity mismatch');
+        const access = z.enum(['read-only', 'spend']).parse(get('spending.mcpAccess') ?? 'read-only');
+        const proposed = parseOperation('limits_propose', { policy: get('spending.policy') ?? { perRequest: null, rolling: [] }, access, pool: get('spending.pool') ?? { indexes: [0], consolidate: false } });
+        const pending = state.prepare("SELECT COUNT(*) AS count FROM settings, json_each(settings.value) WHERE settings.key = 'spending.records' AND json_extract(json_each.value, '$.status') IN ('reserved', 'signed', 'unknown')").get();
+        const terms = get('market.terms');
+        return { settings, settingsSource: 'profile', identity, addresses, access, permissions,
+            poolIndexes: proposed.pool.indexes, pendingPayments: Number(pending?.count ?? 0),
+            resetPending: Boolean(get('wallet.reset')), termsAccepted: terms?.version === marketTerms.version };
+    }
+    finally {
+        state.close();
+    }
+}

package/dist/doctor/types.d.ts

@@ -0,0 +1,40 @@
+export type DoctorStatus = 'pass' | 'warn' | 'fail' | 'skipped';
+export interface DoctorCheck {
+    id: string;
+    status: DoctorStatus;
+    code: string;
+    message: string;
+    evidence?: Record<string, unknown>;
+    remediation?: {
+        steps: string[];
+        command?: string[];
+        suggestedEnv?: Record<string, string>;
+        restartRequired?: boolean;
+    };
+}
+export interface DoctorOptions {
+    directory?: string;
+    access?: 'mcp';
+    signal?: AbortSignal;
+    globalDirectory?: boolean;
+}
+export interface DoctorReport {
+    status: 'pass' | 'warn' | 'fail';
+    context: {
+        interface: 'cli' | 'mcp';
+        executable: string;
+        nodeVersion: string;
+        cliVersion: string;
+        mcpVersion?: string;
+        platform: string;
+        directory?: string;
+        credentialService?: string;
+        credentialAccount?: string;
+        network?: string;
+        nodeUrl?: string;
+        workerUrl?: string;
+        settingsSource?: 'profile' | 'defaults';
+    };
+    checks: DoctorCheck[];
+    durationMs: number;
+}

package/dist/doctor/types.js

@@ -0,0 +1 @@
+export {};

package/dist/domain/amount.d.ts

@@ -0,0 +1,6 @@
+import type { AmountUnit } from '../wallet/types.js';
+export declare function amountRaw(value: string, unit?: AmountUnit, allowZero?: boolean): string;
+export declare function amountOutput(raw: string): {
+    raw: string;
+    atto: string;
+};

package/dist/domain/amount.js

@@ -0,0 +1,27 @@
+import { AttoAmount, AttoUnit } from '@attocash/commons-core';
+import { AttoError } from './errors.js';
+export function amountRaw(value, unit = 'ATTO', allowZero = false) {
+    if (typeof value !== 'string' || !/^\d+(?:\.\d+)?$/.test(value) || !['ATTO', 'RAW'].includes(unit)) {
+        throw new AttoError('INVALID_AMOUNT', 'Use a nonnegative decimal string with an ATTO or RAW unit.');
+    }
+    const fraction = (value.split('.')[1] ?? '').replace(/0+$/, '');
+    if (fraction.length > (unit === 'ATTO' ? 9 : 0)) {
+        throw new AttoError('INVALID_AMOUNT', 'ATTO supports nine decimal places; RAW must be a whole number.');
+    }
+    try {
+        const normalized = `${value.split('.')[0]}${fraction ? `.${fraction}` : ''}`;
+        const amount = AttoAmount.from(unit === 'RAW' ? AttoUnit.RAW : AttoUnit.ATTO, normalized);
+        const raw = amount.toString();
+        if (!allowZero && BigInt(raw) === 0n)
+            throw new Error();
+        return raw;
+    }
+    catch {
+        throw new AttoError('INVALID_AMOUNT', 'Amount is outside the Atto range or precision.');
+    }
+}
+export function amountOutput(raw) {
+    const value = BigInt(raw);
+    const fraction = (value % 1000000000n).toString().padStart(9, '0').replace(/0+$/, '');
+    return { raw, atto: `${value / 1000000000n}${fraction ? `.${fraction}` : ''}` };
+}

package/dist/domain/errors.d.ts

@@ -0,0 +1,10 @@
+export declare class AttoError extends Error {
+    readonly code: string;
+    readonly details?: unknown | undefined;
+    constructor(code: string, message: string, details?: unknown | undefined);
+}
+export declare function errorResult(error: unknown): {
+    code: string;
+    message: string;
+    details?: unknown;
+};

package/dist/domain/errors.js

@@ -0,0 +1,16 @@
+export class AttoError extends Error {
+    code;
+    details;
+    constructor(code, message, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = 'AttoError';
+    }
+}
+export function errorResult(error) {
+    if (error instanceof AttoError)
+        return { code: error.code, message: error.message, details: error.details };
+    // Dependency errors can include request headers or key material. Never return their raw messages.
+    return { code: 'OPERATION_FAILED', message: 'The operation failed. Check wallet status and endpoint availability.' };
+}

package/dist/labels/directory.d.ts

@@ -0,0 +1,87 @@
+import { z } from 'zod';
+export declare const DIRECTORY_URL = "https://gatekeeper.live.application.atto.cash/projections/addresses";
+export declare const directorySchema: z.ZodObject<{
+    entities: z.ZodArray<z.ZodObject<{
+        entity: z.ZodString;
+        organization: z.ZodString;
+        label: z.ZodString;
+        website: z.ZodString;
+        tags: z.ZodArray<z.ZodString>;
+        addedAt: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>>;
+    addresses: z.ZodArray<z.ZodObject<{
+        address: z.ZodString;
+        label: z.ZodString;
+        entity: z.ZodString;
+        addedAt: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>>;
+    voters: z.ZodArray<z.ZodObject<{
+        address: z.ZodString;
+        label: z.ZodString;
+        entity: z.ZodString;
+        addedAt: z.ZodString;
+        description: z.ZodString;
+        payToAddress: z.ZodNullable<z.ZodString>;
+        sharePercentage: z.ZodNumber;
+        voteWeight: z.ZodString;
+        lastVotedAt: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type DirectorySnapshot = z.infer<typeof directorySchema>;
+/** Fetches only the public URL, with no wallet addresses or personal labels. */
+export declare function fetchDirectory(fetcher?: typeof fetch, signal?: AbortSignal): Promise<DirectorySnapshot>;
+/** Disposable public cache, kept outside the profile's durable SQLite state. */
+export declare class GlobalDirectory {
+    private readonly directory;
+    private readonly fetcher;
+    private readonly now;
+    private pending?;
+    private memory;
+    private readonly path;
+    constructor(directory: string, fetcher?: typeof fetch, now?: () => number);
+    private read;
+    private save;
+    cached(): {
+        snapshot: {
+            entities: {
+                entity: string;
+                organization: string;
+                label: string;
+                website: string;
+                tags: string[];
+                addedAt: string;
+                description: string;
+            }[];
+            addresses: {
+                address: string;
+                label: string;
+                entity: string;
+                addedAt: string;
+                description: string;
+            }[];
+            voters: {
+                address: string;
+                label: string;
+                entity: string;
+                addedAt: string;
+                description: string;
+                payToAddress: string | null;
+                sharePercentage: number;
+                voteWeight: string;
+                lastVotedAt: string;
+            }[];
+        } | undefined;
+        status: {
+            lastError?: string | undefined;
+            retryAt?: string | undefined;
+            fetchedAt?: string | undefined;
+            source: string;
+            network: string;
+            available: boolean;
+            stale: boolean;
+        };
+    };
+    refresh(force?: boolean): Promise<void>;
+}

package/dist/labels/directory.js

@@ -0,0 +1,140 @@
+import { mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { z } from 'zod';
+import { parseAddress } from '../network/reader.js';
+export const DIRECTORY_URL = 'https://gatekeeper.live.application.atto.cash/projections/addresses';
+const FRESH_MS = 3_600_000;
+const RETRY_MS = 300_000;
+const MAX_BYTES = 2 * 1024 * 1024;
+const string = z.string().max(4096);
+const address = z.string().max(128).refine(value => { try {
+    return parseAddress(value).value === value;
+}
+catch {
+    return false;
+} });
+const entity = z.object({ entity: string, organization: string, label: string, website: string, tags: z.array(string).max(100), addedAt: string, description: string });
+const entry = z.object({ address, label: string, entity: string, addedAt: string, description: string });
+const voter = entry.extend({ payToAddress: address.nullable(), sharePercentage: z.number().min(0).max(100), voteWeight: z.string().regex(/^\d+$/).max(40), lastVotedAt: string });
+export const directorySchema = z.object({ entities: z.array(entity).max(10_000), addresses: z.array(entry).max(10_000), voters: z.array(voter).max(10_000) })
+    .superRefine((snapshot, context) => {
+    const entities = new Set(snapshot.entities.map(value => value.entity));
+    if (entities.size !== snapshot.entities.length || [...snapshot.addresses, ...snapshot.voters].some(value => !entities.has(value.entity))) {
+        context.addIssue({ code: 'custom', message: 'Invalid directory entity references.' });
+    }
+});
+/** Fetches only the public URL, with no wallet addresses or personal labels. */
+export async function fetchDirectory(fetcher = fetch, signal) {
+    const response = await fetcher(DIRECTORY_URL, { signal: AbortSignal.any([AbortSignal.timeout(3000), ...(signal ? [signal] : [])]), redirect: 'error', headers: { accept: 'application/json' } });
+    try {
+        if (!response.ok || !response.body || !/^application\/json\b/i.test(response.headers.get('content-type') ?? '')
+            || Number(response.headers.get('content-length') ?? 0) > MAX_BYTES)
+            throw new Error('Invalid directory response.');
+        const reader = response.body.getReader();
+        const chunks = [];
+        let size = 0;
+        try {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                size += value.length;
+                if (size > MAX_BYTES)
+                    throw new Error('Directory response too large.');
+                chunks.push(value);
+            }
+        }
+        finally {
+            await reader.cancel();
+            reader.releaseLock();
+        }
+        return directorySchema.parse(JSON.parse(Buffer.concat(chunks).toString('utf8')));
+    }
+    finally {
+        if (!response.body?.locked)
+            await response.body?.cancel();
+    }
+}
+/** Disposable public cache, kept outside the profile's durable SQLite state. */
+export class GlobalDirectory {
+    directory;
+    fetcher;
+    now;
+    pending;
+    memory = {};
+    path;
+    constructor(directory, fetcher = fetch, now = Date.now) {
+        this.directory = directory;
+        this.fetcher = fetcher;
+        this.now = now;
+        this.path = join(directory, 'cache', 'global-addresses.json');
+    }
+    read() {
+        try {
+            if (statSync(this.path).size > MAX_BYTES + 1024)
+                throw new Error();
+            const bytes = readFileSync(this.path);
+            if (bytes.length > MAX_BYTES + 1024)
+                throw new Error();
+            const cache = JSON.parse(bytes.toString('utf8'));
+            for (const time of [cache.fetchedAt, cache.failedAt])
+                if (time !== undefined && (!Number.isSafeInteger(time) || time < 0 || time > 8_640_000_000_000_000 - RETRY_MS))
+                    throw new Error();
+            if (cache.snapshot) {
+                cache.snapshot = directorySchema.parse(cache.snapshot);
+                if (cache.fetchedAt === undefined)
+                    throw new Error();
+            }
+            return this.memory = cache;
+        }
+        catch {
+            return this.memory;
+        }
+    }
+    save(cache) {
+        this.memory = cache;
+        const temporary = `${this.path}.${randomUUID()}.tmp`;
+        try {
+            mkdirSync(join(this.directory, 'cache'), { recursive: true, mode: 0o700 });
+            writeFileSync(temporary, JSON.stringify(cache), { mode: 0o600 });
+            renameSync(temporary, this.path);
+        }
+        catch { /* Public-cache storage failures must not break wallet operations. */ }
+        finally {
+            try {
+                rmSync(temporary, { force: true });
+            }
+            catch { /* Best effort. */ }
+        }
+    }
+    cached() {
+        const cache = this.read();
+        return { snapshot: cache.snapshot, status: { source: DIRECTORY_URL, network: 'LIVE',
+                available: Boolean(cache.snapshot), stale: !cache.snapshot || this.now() - cache.fetchedAt >= FRESH_MS,
+                ...(cache.fetchedAt !== undefined ? { fetchedAt: new Date(cache.fetchedAt).toISOString() } : {}),
+                ...(cache.failedAt !== undefined ? { lastError: 'DIRECTORY_UNAVAILABLE', retryAt: new Date(cache.failedAt + RETRY_MS).toISOString() } : {}) } };
+    }
+    async refresh(force = false) {
+        if (this.pending)
+            return this.pending;
+        const cache = this.read();
+        if (!force && ((cache.fetchedAt !== undefined && this.now() - cache.fetchedAt < FRESH_MS)
+            || (cache.failedAt !== undefined && this.now() - cache.failedAt < RETRY_MS)))
+            return;
+        this.pending = (async () => {
+            try {
+                this.save({ snapshot: await fetchDirectory(this.fetcher), fetchedAt: this.now() });
+            }
+            catch {
+                this.save({ ...cache, failedAt: this.now() });
+            }
+        })();
+        try {
+            await this.pending;
+        }
+        finally {
+            this.pending = undefined;
+        }
+    }
+}

package/dist/labels/personal.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import type { StateStore } from '../storage/state.js';
+import type { NetworkName } from '../wallet/types.js';
+export declare const personalNameSchema: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+export declare const nameKey: (name: string) => string;
+export interface PersonalLabel {
+    address: string;
+    label: string;
+}
+export declare class PersonalLabels {
+    private readonly store;
+    constructor(store: StateStore);
+    list(network: NetworkName): PersonalLabel[];
+    set(network: NetworkName, address: string, input: string): PersonalLabel;
+    remove(network: NetworkName, address: string): void;
+    resolve(network: NetworkName, label: string): PersonalLabel;
+}

package/dist/labels/personal.js

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+import { AttoError } from '../domain/errors.js';
+import { parseAddress } from '../network/reader.js';
+// Count Unicode code points, not UTF-16 units. Formatting controls are rejected
+// too, so invisible direction changes cannot disguise a payment destination.
+export const personalNameSchema = z.string().refine(value => !/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/u.test(value), 'Labels cannot contain control characters.')
+    .transform(value => value.trim()).refine(value => [...value].length >= 1 && [...value].length <= 128, 'Labels must contain 1–128 characters after trimming.');
+export const nameKey = (name) => name.trim().toLowerCase();
+export class PersonalLabels {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    list(network) {
+        const rows = this.store.get(`labels.personal.${network}`) ?? [];
+        try {
+            if (!Array.isArray(rows))
+                throw new Error();
+            const names = new Set();
+            const addresses = new Set();
+            for (const row of rows) {
+                if (parseAddress(row.address).value !== row.address || personalNameSchema.parse(row.label) !== row.label
+                    || names.has(nameKey(row.label)) || addresses.has(row.address))
+                    throw new Error();
+                names.add(nameKey(row.label));
+                addresses.add(row.address);
+            }
+            return rows;
+        }
+        catch {
+            throw new AttoError('INVALID_STATE', 'The saved personal labels are invalid. Restore verified profile state.');
+        }
+    }
+    set(network, address, input) {
+        const label = personalNameSchema.parse(input);
+        address = parseAddress(address).value;
+        return this.store.transaction(() => {
+            const rows = this.list(network);
+            if (rows.some(row => nameKey(row.label) === nameKey(label) && row.address !== address)) {
+                throw new AttoError('LABEL_EXISTS', 'This personal name already belongs to another address on this network.');
+            }
+            const row = { address, label };
+            this.store.set(`labels.personal.${network}`, [...rows.filter(row => row.address !== address), row]);
+            return row;
+        });
+    }
+    remove(network, address) {
+        this.store.transaction(() => this.store.set(`labels.personal.${network}`, this.list(network).filter(row => row.address !== address)));
+    }
+    resolve(network, label) {
+        const row = this.list(network).find(row => nameKey(row.label) === nameKey(label));
+        if (!row)
+            throw new AttoError('LABEL_NOT_FOUND', 'No personal label matches this name on this network. Global names cannot be used for payments.');
+        return row;
+    }
+}

package/dist/labels/presentation.d.ts

@@ -0,0 +1,154 @@
+import type { NetworkName } from '../wallet/types.js';
+import { GlobalDirectory } from './directory.js';
+import { PersonalLabels } from './personal.js';
+export declare function modelAddress(value: Record<string, unknown>, prefix?: string): string | undefined;
+/** Read protocol keys without rewriting network objects or interpreting metadata. */
+export declare function resultAddresses(value: unknown): string[];
+export declare class AddressLabels {
+    private readonly personal;
+    readonly global: GlobalDirectory;
+    constructor(personal: PersonalLabels, global: GlobalDirectory);
+    dictionary(network: NetworkName, addresses: string[]): {
+        [k: string]: {
+            global: ({
+                source: string;
+                entityInfo: {
+                    entity: string;
+                    organization: string;
+                    label: string;
+                    website: string;
+                    tags: string[];
+                    addedAt: string;
+                    description: string;
+                } | undefined;
+                stale: boolean;
+                kind: "address";
+                address: string;
+                label: string;
+                entity: string;
+                addedAt: string;
+                description: string;
+            } | {
+                source: string;
+                entityInfo: {
+                    entity: string;
+                    organization: string;
+                    label: string;
+                    website: string;
+                    tags: string[];
+                    addedAt: string;
+                    description: string;
+                } | undefined;
+                stale: boolean;
+                kind: "voter";
+                address: string;
+                label: string;
+                entity: string;
+                addedAt: string;
+                description: string;
+                payToAddress: string | null;
+                sharePercentage: number;
+                voteWeight: string;
+                lastVotedAt: string;
+            })[];
+            payoutFor: {
+                voterAddress: string;
+                label: string;
+                entity: string;
+                source: string;
+                stale: boolean;
+            }[];
+            personal?: {
+                source: string;
+                label: string;
+            } | undefined;
+        };
+    };
+    status(network: NetworkName): {
+        lastError?: string | undefined;
+        retryAt?: string | undefined;
+        fetchedAt?: string | undefined;
+        source: string;
+        network: string;
+        available: boolean;
+        stale: boolean;
+    } | {
+        network: string;
+        applicable: boolean;
+    };
+    list(network: NetworkName, all?: boolean, search?: string): {
+        network: NetworkName;
+        items: {
+            address: string;
+        }[];
+        addressLabels: {
+            [k: string]: {
+                global: ({
+                    source: string;
+                    entityInfo: {
+                        entity: string;
+                        organization: string;
+                        label: string;
+                        website: string;
+                        tags: string[];
+                        addedAt: string;
+                        description: string;
+                    } | undefined;
+                    stale: boolean;
+                    kind: "address";
+                    address: string;
+                    label: string;
+                    entity: string;
+                    addedAt: string;
+                    description: string;
+                } | {
+                    source: string;
+                    entityInfo: {
+                        entity: string;
+                        organization: string;
+                        label: string;
+                        website: string;
+                        tags: string[];
+                        addedAt: string;
+                        description: string;
+                    } | undefined;
+                    stale: boolean;
+                    kind: "voter";
+                    address: string;
+                    label: string;
+                    entity: string;
+                    addedAt: string;
+                    description: string;
+                    payToAddress: string | null;
+                    sharePercentage: number;
+                    voteWeight: string;
+                    lastVotedAt: string;
+                })[];
+                payoutFor: {
+                    voterAddress: string;
+                    label: string;
+                    entity: string;
+                    source: string;
+                    stale: boolean;
+                }[];
+                personal?: {
+                    source: string;
+                    label: string;
+                } | undefined;
+            } | undefined;
+        };
+        globalDirectory: {
+            lastError?: string | undefined;
+            retryAt?: string | undefined;
+            fetchedAt?: string | undefined;
+            source: string;
+            network: string;
+            available: boolean;
+            stale: boolean;
+        } | {
+            network: string;
+            applicable: boolean;
+        };
+    };
+    decorate(result: unknown, network: NetworkName): unknown;
+}