@defdone/annon 0.0.0-stage → 0.1.0-alpha.1

package/dist/net/ip.d.ts

@@ -0,0 +1,7 @@
+export declare function clientKey(header: string | string[] | undefined, socket: string | undefined): string;
+/** Bounded fixed windows; overflow shares a bucket instead of bypassing admission. */
+export declare function fixedWindowLimiter(limit: number, windowMs?: number, now?: () => number, maxKeys?: number): (key: string) => {
+    allowed: boolean;
+    retryAfterSeconds: number;
+};
+export declare function limiter(perMinute: number, now?: () => number, maxKeys?: number): (key: string) => boolean;

package/dist/net/ip.js

@@ -0,0 +1,62 @@
+/** Canonical proxy/socket client buckets shared by the services. IPv6 uses /48. */
+function canonical(value) {
+    if (typeof value !== 'string' ||
+        value.length > 64 ||
+        value !== value.trim() ||
+        /[%\s,[\]]/.test(value))
+        return;
+    if (!value.includes(':')) {
+        const parts = value.split('.');
+        if (parts.length === 4 && parts.every((p) => /^(0|[1-9]\d{0,2})$/.test(p) && Number(p) <= 255))
+            return parts.join('.');
+        return;
+    }
+    try {
+        const host = new URL(`http://[${value}]/`).hostname.slice(1, -1);
+        const [head = '', tail = ''] = host.split('::');
+        const a = head ? head.split(':') : [];
+        const b = tail ? tail.split(':') : [];
+        const words = host.includes('::')
+            ? [...a, ...Array(8 - a.length - b.length).fill('0'), ...b]
+            : a;
+        if (words.length !== 8)
+            return;
+        const n = words.map((w) => Number.parseInt(w, 16));
+        if (n.slice(0, 5).every((w) => w === 0) && n[5] === 65535) {
+            const hi = n[6];
+            const lo = n[7];
+            return [hi >> 8, hi & 255, lo >> 8, lo & 255].join('.');
+        }
+        return `${n
+            .slice(0, 3)
+            .map((w) => w.toString(16))
+            .join(':')}::/48`;
+    }
+    catch {
+        return;
+    }
+}
+export function clientKey(header, socket) {
+    return canonical(header) ?? canonical(socket) ?? 'unknown';
+}
+/** Bounded fixed windows; overflow shares a bucket instead of bypassing admission. */
+export function fixedWindowLimiter(limit, windowMs = 60_000, now = () => Date.now(), maxKeys = 50_000) {
+    let window = -1;
+    let hits = new Map();
+    return (key) => {
+        const t = now();
+        const w = Math.floor(t / windowMs);
+        if (w !== window) {
+            window = w;
+            hits = new Map();
+        }
+        const k = hits.has(key) || hits.size < maxKeys ? key : '*';
+        const n = (hits.get(k) ?? 0) + 1;
+        hits.set(k, n);
+        return { allowed: n <= limit, retryAfterSeconds: Math.ceil(((w + 1) * windowMs - t) / 1000) };
+    };
+}
+export function limiter(perMinute, now = () => Date.now(), maxKeys = 50_000) {
+    const check = fixedWindowLimiter(perMinute, 60_000, now, maxKeys);
+    return (key) => check(key).allowed;
+}

package/dist/net/retry.d.ts

@@ -0,0 +1,3 @@
+/** Retry-After in milliseconds, preserving the full server wait. Unknown values stay unknown. */
+export declare function parseRetryAfterMs(value: string | null | undefined, now?: number): number | undefined;
+export declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;

package/dist/net/retry.js

@@ -0,0 +1,31 @@
+/** Retry-After in milliseconds, preserving the full server wait. Unknown values stay unknown. */
+export function parseRetryAfterMs(value, now = Date.now()) {
+    if (!value?.trim())
+        return;
+    const text = value.trim();
+    if (/^\d+$/.test(text)) {
+        const n = Number(text) * 1000;
+        return Number.isSafeInteger(n) ? n : undefined;
+    }
+    if (!/^[A-Za-z]{3}, /.test(text))
+        return;
+    const time = Date.parse(text);
+    return Number.isFinite(time) ? Math.max(0, time - now) : undefined;
+}
+export function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(signal.reason);
+            return;
+        }
+        const abort = () => {
+            clearTimeout(timer);
+            reject(signal?.reason);
+        };
+        const timer = setTimeout(() => {
+            signal?.removeEventListener('abort', abort);
+            resolve();
+        }, ms);
+        signal?.addEventListener('abort', abort, { once: true });
+    });
+}

package/dist/node/adapter-checks.d.ts

@@ -0,0 +1,6 @@
+import type { AnnonErrorCode, PublicError } from '../errors.js';
+import type { Config } from './config.js';
+declare const fail: (code: AnnonErrorCode, message: string, exit?: PublicError["exitCode"]) => never;
+declare const isId: (id: string) => boolean;
+declare const backupPath: (c: Config, id: string) => string;
+export { backupPath, fail, isId };

package/dist/node/adapter-checks.js

@@ -0,0 +1,13 @@
+/** Typed adapter failures and the file ID and backup path checks used by the CLI commands. */
+import { join } from 'node:path';
+import { AdapterError, usage } from './errors.js';
+const fail = (code, message, exit = 1) => {
+    throw new AdapterError(code, message, exit);
+};
+const isId = (id) => /^0x[0-9a-f]{64}$/.test(id);
+const backupPath = (c, id) => {
+    if (!/^(recovery:|sell:|seller-key:)?0x[0-9a-f]{64}(:revision:[0-9]+)?$/.test(id))
+        throw usage();
+    return join(c.stateDir, 'backups', `${id.replaceAll(':', '-')}.json`);
+};
+export { backupPath, fail, isId };

package/dist/node/adapter.d.ts

@@ -0,0 +1,8 @@
+/** Node I/O around the SDK. Settlement, commitments, encryption and proofs stay in the SDK. */
+import { type Dependencies } from './core-adapter.js';
+import type { Input } from './cli.js';
+import { type Environment } from './wallets.js';
+export { amount, nearAmount } from './amounts.js';
+export type { Dependencies } from './core-adapter.js';
+/** CLI session lifetime includes every wallet action and is always closed on exit. */
+export declare function createAdapter(env?: Environment, d?: Dependencies): (o: Input) => Promise<Record<string, unknown>>;

package/dist/node/adapter.js

@@ -0,0 +1,98 @@
+/** Node I/O around the SDK. Settlement, commitments, encryption and proofs stay in the SDK. */
+import { createCoreAdapter } from './core-adapter.js';
+// core-adapter.js loads first: it imports the SDK modules in the order this file did, so they initialize as before.
+import { identityJson, parseIdentity } from '../settle-near/identity.js';
+import { agentPolicy, configPath, initAgent, savePublicConfig } from './agent.js';
+import { startBrowserSession } from './browser-login.js';
+import { loadConfig } from './config.js';
+import { AdapterError } from './errors.js';
+import { osKeychain } from './keychain.js';
+import { confinePaths } from './paths.js';
+import { discoverShops, isDiscovery } from './shops.js';
+import { assertSignerInput, configuredWallet } from './signer-wallet.js';
+import { signingRequest, verifySigningResult } from './signing.js';
+import { identity } from './wallets.js';
+export { amount, nearAmount } from './amounts.js';
+/** CLI session lifetime includes every wallet action and is always closed on exit. */
+export function createAdapter(env = process.env, d = {}) {
+    return async (o) => {
+        if (o.command !== 'init' && (o.signer || o.credentialEnv || o.credentialKeychain))
+            throw new AdapterError('signer_init_only', 'Signer and credential references can only be set by init.', 2);
+        const agent = await agentPolicy(o, env, d.agent);
+        if (isDiscovery(o))
+            return discoverShops(o, env, agent, d.fetch);
+        if (o.command === 'init')
+            return initAgent(o, env, d.keychain ?? osKeychain);
+        const c = await loadConfig(o, env, o.command === 'login', d.agent);
+        if (agent || c.agent)
+            o = await confinePaths(o, c.workDir);
+        if (c.signer) {
+            assertSignerInput(o);
+            if (o.recovery && identityJson(identity(o.recovery)) !== identityJson(c.signer.identity))
+                throw new AdapterError('wrong_identity', 'Recovery must match the configured signer.', 2);
+        }
+        if ((agent || c.agent) && o.command === 'login')
+            throw new AdapterError('agent_policy', 'Agent mode refuses interactive login.', 2);
+        let session;
+        let terms = null;
+        const browser = async () => {
+            if (!session) {
+                session = await (d.browser ?? startBrowserSession)({ noOpen: o.noOpen === true });
+                const port = new URL(session.url).port;
+                d.notify?.(`Annon pairing code ${session.pairingCode}${o.noOpen ? `\n${session.url}` : ''}\nFor SSH: forward this port with ssh -L ${port}:127.0.0.1:${port} host. Use --no-open for a manual pairing URL.`);
+            }
+            return session;
+        };
+        try {
+            if (o.command === 'login') {
+                const s = await browser();
+                const kind = o.wallet ?? 'evm';
+                if (kind === 'solana')
+                    throw new Error('browser Solana login is not supported');
+                const challenge = `Annon login: ${crypto.randomUUID()} on ${c.network}`;
+                const q = signingRequest(kind === 'evm' ? 'evm.personalSign' : 'near.nep413', kind === 'evm' ? 'eip155:8453' : c.network, '', kind === 'evm'
+                    ? { message: challenge }
+                    : {
+                        message: challenge,
+                        recipient: c.contractId || 'annon-cli',
+                        nonce: [...crypto.getRandomValues(new Uint8Array(32))],
+                    });
+                let identity;
+                await s.request(q, async (r) => {
+                    const selected = parseIdentity({ kind, id: kind === 'evm' ? r.account : r.accountId });
+                    await verifySigningResult({ ...q, account: selected.id }, r, c.nearRpc);
+                    identity = selected;
+                });
+                if (!identity)
+                    throw new Error('login failed');
+                await savePublicConfig(configPath(o, env), {
+                    signer: { mode: 'browser', identity },
+                    agent: false,
+                    network: c.network,
+                    nearRpc: c.nearRpc,
+                    ...(c.contractId ? { contractId: c.contractId } : {}),
+                    ...(c.baseRpc ? { baseRpc: c.baseRpc } : {}),
+                });
+                return { identity, network: c.network, mode: 'browser' };
+            }
+            const signer = c.signer;
+            return await createCoreAdapter(env, {
+                ...d,
+                agent: agent || c.agent === true,
+                browserApprovals: signer?.mode === 'browser',
+                paymentTerms: (value) => {
+                    terms = value;
+                    d.paymentTerms?.(value);
+                },
+                ...(signer && !d.wallet
+                    ? {
+                        wallet: (input, environment) => configuredWallet(signer, c, input, environment, d.keychain ?? osKeychain, browser, () => terms),
+                    }
+                    : {}),
+            })(o);
+        }
+        finally {
+            await session?.close();
+        }
+    };
+}

package/dist/node/agent.d.ts

@@ -0,0 +1,49 @@
+import { type Identity } from '../settle-near/identity.js';
+import type { Input } from './cli.js';
+import { type Keychain } from './keychain.js';
+import { type Environment } from './wallets.js';
+export type SignerConfig = {
+    mode: 'browser';
+    identity: Identity;
+} | {
+    mode: 'file';
+    kind: 'evm' | 'near' | 'solana';
+    file: string;
+    identity: Identity;
+} | {
+    mode: 'env';
+    kind: 'evm' | 'near' | 'solana';
+    name: string;
+    identity: Identity;
+} | {
+    mode: 'keychain';
+    kind: 'evm' | 'near';
+    entry: string;
+    identity: Identity;
+    publicKey?: string;
+} | {
+    mode: 'remote';
+    url: string;
+    credential: {
+        env: string;
+    } | {
+        keychain: string;
+    };
+    identity: Identity;
+    publicKey?: string;
+};
+export declare const configPath: (o: Partial<Input>, env: Environment) => string;
+/** The launcher environment and its config are the agent policy anchor, never per-call flags. */
+export declare function agentPolicy(o: Input, env: Environment, forced?: boolean): Promise<boolean>;
+export declare function savePublicConfig(path: string, patch: {
+    signer: SignerConfig;
+    dailyBudget?: string;
+    agent: boolean;
+    network?: string;
+    nearRpc?: string;
+    contractId?: string;
+    baseRpc?: string;
+}): Promise<void>;
+export declare function initAgent(o: Input, env: Environment, keychain?: Keychain): Promise<Record<string, unknown>>;
+/** Reject plaintext credentials and unknown persisted signer fields at the config boundary. */
+export declare function validateSigner(s: SignerConfig): SignerConfig;

package/dist/node/agent.js

@@ -0,0 +1,266 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { secureUrl } from '../download/download.js';
+import { account, network } from '../settle-near/codec.js';
+import { parseIdentity } from '../settle-near/identity.js';
+import { validateDiscoveryConfig } from '../shops/discovery.js';
+import { AdapterError } from './errors.js';
+import { osKeychain } from './keychain.js';
+import { remoteSigner } from './signing.js';
+import { identity } from './wallets.js';
+export const configPath = (o, env) => {
+    const home = join(homedir(), '.config', 'annon', 'config.json');
+    if (env.ANNON_AGENT !== 'true')
+        return o.config ?? env.ANNON_CONFIG ?? home;
+    // Agent mode pins the home config; a different ANNON_CONFIG is an operator mistake, not a silent override.
+    if (env.ANNON_CONFIG && resolve(env.ANNON_CONFIG) !== resolve(home))
+        throw new AdapterError('config_conflict', 'ANNON_AGENT=true always uses ~/.config/annon/config.json; unset ANNON_CONFIG or point it there.', 2);
+    return home;
+};
+/** The launcher environment and its config are the agent policy anchor, never per-call flags. */
+export async function agentPolicy(o, env, forced = false) {
+    const pinned = configPath({}, env);
+    const home = join(homedir(), '.config', 'annon', 'config.json');
+    if (resolve(pinned) !== resolve(home)) {
+        try {
+            if (JSON.parse(await readFile(home, 'utf8')).agent === true)
+                throw new AdapterError('config_conflict', 'The home config enables agent mode. Unset ANNON_CONFIG or point it there.', 2);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+    }
+    let saved = {};
+    try {
+        saved = JSON.parse(await readFile(pinned, 'utf8'));
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    const agent = forced || env.ANNON_AGENT === 'true' || saved.agent === true;
+    if (agent &&
+        (o.command === 'init' ||
+            o.command === 'login' ||
+            (o.config !== undefined && resolve(o.config) !== resolve(pinned)) ||
+            o.stateDir !== undefined ||
+            [
+                o.contractId,
+                o.nearRpc,
+                o.baseRpc,
+                o.relayer,
+                o.network,
+                o.trustContract,
+                o.moderator,
+                o.maxPrice,
+                o.storageBudget,
+                o.listingStorage,
+                o.fundAmount,
+            ].some((v) => v !== undefined)))
+        throw new AdapterError('agent_policy', 'Agent mode pins deployment, trust, price and state policy; per-call overrides, init and login are refused.', 2);
+    return agent;
+}
+export async function savePublicConfig(path, patch) {
+    let old = {};
+    try {
+        old = JSON.parse(await readFile(path, 'utf8'));
+    }
+    catch (e) {
+        if (e.code !== 'ENOENT')
+            throw e;
+    }
+    validateDiscoveryConfig(old);
+    const allowed = [
+        'shopDirectoryUrl',
+        'shops',
+        'defaultShop',
+        'contractId',
+        'nearRpc',
+        'baseRpc',
+        'network',
+        'stateDir',
+        'workDir',
+        'relayer',
+        'maxPrice',
+        'trustContract',
+        'mpcKey',
+        'moderators',
+        'origins',
+        'allowedResources',
+        'storageBudget',
+        'listingStorage',
+        'maxProtocolFee',
+    ];
+    const publicConfig = Object.fromEntries(Object.entries(old).filter(([k]) => allowed.includes(k)));
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    const tmp = `${path}.${randomUUID()}.tmp`;
+    await writeFile(tmp, JSON.stringify({ network: 'near:mainnet', ...publicConfig, ...patch }, null, 2), {
+        mode: 0o600,
+        flag: 'wx',
+    });
+    await rename(tmp, path);
+}
+export async function initAgent(o, env, keychain = osKeychain) {
+    await agentPolicy(o, env);
+    if ((o.config !== undefined && resolve(o.config) !== resolve(configPath({}, env))) ||
+        o.stateDir !== undefined)
+        throw new AdapterError('agent_policy', 'Set the trusted ANNON_CONFIG and ANNON_STATE_DIR launcher environment before init; per-call agent paths are refused.', 2);
+    if (!o.agent || !o.dailyBudget || !/^(0|[1-9][0-9]*)(\.[0-9]{1,6})?$/.test(o.dailyBudget))
+        throw new AdapterError('budget_required', 'init --agent requires --daily-budget in USDC.', 2);
+    const kind = o.wallet ??
+        (o.recovery
+            ? identity(o.recovery).kind
+            : o.evmKeyFile
+                ? 'evm'
+                : o.solanaKeyFile
+                    ? 'solana'
+                    : 'near');
+    let selected = o.recovery
+        ? identity(o.recovery)
+        : o.nearAccount
+            ? parseIdentity({ kind: 'near', id: o.nearAccount })
+            : undefined;
+    const choices = [
+        o.signer,
+        o.newKey,
+        o.keyEnv,
+        !o.newKey && o.keychainEntry,
+        o.evmKeyFile,
+        o.nearKeyFile,
+        o.solanaKeyFile,
+    ].filter(Boolean);
+    if (choices.length !== 1)
+        throw new AdapterError('signer_required', 'Choose exactly one key reference, new keychain key or remote signer.', 2);
+    let signer;
+    if (o.signer) {
+        remoteSigner({ url: o.signer, credential: async () => '' });
+        if (!selected ||
+            (!o.credentialEnv && !o.credentialKeychain) ||
+            (o.credentialEnv && o.credentialKeychain))
+            throw new AdapterError('signer_required', 'Remote signing requires an identity and exactly one credential reference.', 2);
+        signer = {
+            mode: 'remote',
+            url: o.signer,
+            identity: selected,
+            credential: o.credentialEnv
+                ? { env: o.credentialEnv }
+                : { keychain: o.credentialKeychain },
+            ...(o.nearPublicKey ? { publicKey: o.nearPublicKey } : {}),
+        };
+    }
+    else if (o.newKey) {
+        if (kind === 'solana')
+            throw new Error('new Solana keys are not supported');
+        const entry = o.keychainEntry ?? `annon-agent-${randomUUID()}`;
+        const created = await keychain.create(kind, entry, o.nearAccount);
+        selected = parseIdentity({ kind: created.kind, id: created.id });
+        signer = {
+            mode: 'keychain',
+            entry,
+            kind,
+            identity: selected,
+            ...(created.publicKey ? { publicKey: created.publicKey } : {}),
+        };
+    }
+    else if (o.keyEnv) {
+        if (!/^[A-Z_][A-Z0-9_]*$/.test(o.keyEnv))
+            throw new Error('invalid environment reference');
+        if (!selected)
+            throw new Error('signer identity required');
+        signer = { mode: 'env', kind, name: o.keyEnv, identity: selected };
+    }
+    else if (o.keychainEntry) {
+        if (kind === 'solana' || !selected)
+            throw new Error('keychain identity required');
+        signer = {
+            mode: 'keychain',
+            entry: o.keychainEntry,
+            kind,
+            identity: selected,
+            ...(o.nearPublicKey ? { publicKey: o.nearPublicKey } : {}),
+        };
+    }
+    else {
+        if (!selected)
+            throw new Error('signer identity required');
+        signer = {
+            mode: 'file',
+            kind,
+            file: resolve((o.evmKeyFile ?? o.nearKeyFile ?? o.solanaKeyFile)),
+            identity: selected,
+        };
+    }
+    validateSigner(signer);
+    const chain = o.network ?? env.ANNON_NETWORK;
+    const endpoints = {
+        ...(o.nearRpc ? { nearRpc: o.nearRpc } : {}),
+        ...(o.baseRpc ? { baseRpc: o.baseRpc } : {}),
+    };
+    for (const endpoint of Object.values(endpoints)) {
+        const url = secureUrl(endpoint);
+        if (url.username || url.password || url.search || url.hash)
+            throw new Error('invalid public endpoint');
+    }
+    if (o.contractId)
+        account(o.contractId);
+    if (chain)
+        network(chain);
+    await savePublicConfig(configPath(o, env), {
+        signer,
+        dailyBudget: o.dailyBudget,
+        agent: true,
+        ...endpoints,
+        ...(chain ? { network: chain } : {}),
+        ...(o.contractId ? { contractId: o.contractId } : {}),
+    });
+    return {
+        configured: true,
+        mode: signer.mode,
+        ...(selected ? { identity: selected } : {}),
+        dailyBudget: o.dailyBudget,
+    };
+}
+/** Reject plaintext credentials and unknown persisted signer fields at the config boundary. */
+export function validateSigner(s) {
+    if (!s || typeof s !== 'object')
+        throw new TypeError('invalid signer');
+    const fields = {
+        browser: ['mode', 'identity'],
+        file: ['mode', 'kind', 'file', 'identity'],
+        env: ['mode', 'kind', 'name', 'identity'],
+        keychain: ['mode', 'kind', 'entry', 'identity', 'publicKey'],
+        remote: ['mode', 'url', 'credential', 'identity', 'publicKey'],
+    };
+    if (!Object.hasOwn(fields, s.mode) || Object.keys(s).some((k) => !fields[s.mode].includes(k)))
+        throw new TypeError('unexpected signer fields');
+    if (s.identity)
+        parseIdentity(s.identity);
+    if (!s.identity)
+        throw new TypeError('signer identity required');
+    if ('kind' in s && s.identity && s.kind !== s.identity.kind)
+        throw new TypeError('signer kind/identity mismatch');
+    if ('kind' in s && !['near', 'evm', 'solana'].includes(s.kind))
+        throw new TypeError('invalid signer kind');
+    if (s.mode === 'file' && (typeof s.file !== 'string' || !s.file))
+        throw new TypeError('key file reference required');
+    if (s.mode === 'env' && !/^[A-Z_][A-Z0-9_]*$/.test(s.name))
+        throw new TypeError('environment reference required');
+    if (s.mode === 'keychain' && (typeof s.entry !== 'string' || !s.entry))
+        throw new TypeError('keychain entry required');
+    if (s.mode === 'remote') {
+        remoteSigner({ url: s.url, credential: async () => '' });
+        if (!s.credential ||
+            Object.keys(s.credential).length !== 1 ||
+            !('env' in s.credential || 'keychain' in s.credential))
+            throw new TypeError('credential reference required');
+        if ('env' in s.credential && !/^[A-Z_][A-Z0-9_]*$/.test(s.credential.env))
+            throw new TypeError('invalid credential environment reference');
+        if ('keychain' in s.credential &&
+            (typeof s.credential.keychain !== 'string' || !s.credential.keychain))
+            throw new TypeError('invalid credential keychain reference');
+    }
+    return s;
+}

package/dist/node/amounts.d.ts

@@ -0,0 +1,2 @@
+export declare function amount(text: string): string;
+export declare function nearAmount(text: string): bigint;

package/dist/node/amounts.js

@@ -0,0 +1,20 @@
+/** Parses decimal USDC and NEAR amounts from command input into base units. */
+import { usage } from './errors.js';
+export function amount(text) {
+    if (!/^(0|[1-9][0-9]*)(\.[0-9]{1,6})?$/.test(text))
+        throw usage();
+    const [whole, fraction = ''] = text.split('.');
+    const n = BigInt(whole ?? '') * 1000000n + BigInt(fraction.padEnd(6, '0'));
+    if (n <= 0n || n >= 2n ** 128n)
+        throw usage();
+    return String(n);
+}
+export function nearAmount(text) {
+    if (!/^(0|[1-9][0-9]*)(\.[0-9]{1,24})?$/.test(text))
+        throw usage();
+    const [whole = '0', fraction = ''] = text.split('.');
+    const n = BigInt(whole) * 10n ** 24n + BigInt(fraction.padEnd(24, '0'));
+    if (n <= 0n || n >= 2n ** 128n)
+        throw usage();
+    return n;
+}

package/dist/node/browser-login.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The approval page talks only to this loopback server, the NEAR RPC its Wallet Selector uses
+ * (fixed per network in browser/login.ts, independent of the CLI's configured RPC) and HOT
+ * Wallet's relay; it frames only the HOT widget. EVM wallets are reached through the injected
+ * provider, which needs no connection from the page.
+ */
+export declare const LOGIN_PAGE_CSP = "default-src 'none'; script-src 'self'; connect-src 'self' https://free.rpc.fastnear.com https://test.rpc.fastnear.com https://h4n.app; frame-src https://hot-labs.org; style-src 'self'; img-src 'self' data:; frame-ancestors 'none'; base-uri 'none'; form-action 'none'";
+export interface BrowserSession {
+    url: string;
+    pairingCode: string;
+    request<T>(action: {
+        id: string;
+        expiresAt: number;
+        exact?: unknown;
+    }, verify: (result: T) => Promise<void>): Promise<T>;
+    close(): Promise<void>;
+}
+export declare function startBrowserSession(o: {
+    noOpen?: boolean;
+    open?: (url: string) => void;
+    asset?: string;
+    timeoutMs?: number;
+}): Promise<BrowserSession>;
+/** Only desktop routing and executable lookup reach the browser opener. */
+export declare function browserOpenerEnv(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;