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

package/dist/node/cli.d.ts

@@ -0,0 +1,60 @@
+import type { BuyRoute } from '../routes.js';
+export type Command = 'shops' | 'shop' | 'catalog' | 'fund' | 'budget' | 'share' | 'sell' | 'buy' | 'open' | 'recover' | 'stop' | 'verify' | 'status' | 'login' | 'init';
+export interface Input {
+    command: Command;
+    shop?: string;
+    id?: string;
+    search?: string;
+    limit?: number;
+    offset?: number;
+    storageBudget?: string;
+    listingStorage?: string;
+    title?: string;
+    description?: string;
+    fundAmount?: string;
+    agent?: boolean;
+    noOpen?: boolean;
+    signer?: string;
+    credentialEnv?: string;
+    credentialKeychain?: string;
+    keyEnv?: string;
+    keychainEntry?: string;
+    newKey?: boolean;
+    dailyBudget?: string;
+    target?: string;
+    json?: boolean;
+    config?: string;
+    contractId?: string;
+    nearRpc?: string;
+    baseRpc?: string;
+    network?: string;
+    stateDir?: string;
+    relayer?: string;
+    trustContract?: boolean;
+    wallet?: 'evm' | 'solana' | 'near';
+    evmKeyFile?: string;
+    solanaKeyFile?: string;
+    nearKeyFile?: string;
+    nearAccount?: string;
+    nearPublicKey?: string;
+    backupSecretFile?: string;
+    resume?: string;
+    origin?: string;
+    price?: string;
+    split?: string;
+    base?: boolean;
+    force?: boolean;
+    moderator?: string;
+    route?: BuyRoute;
+    fromChain?: string;
+    fromAsset?: string;
+    refundTo?: string;
+    recovery?: string;
+    maxPrice?: string;
+    purchase?: string;
+    file?: string;
+    url?: string;
+    output?: string;
+}
+export declare function parseCli(argv: string[]): Input;
+export declare function runCli(argv: string[], execute: (input: Input) => Promise<unknown>, write: (text: string) => void): Promise<number>;

package/dist/node/cli.js

@@ -0,0 +1,201 @@
+import { parseArgs } from 'node:util';
+import { publicError, usage } from './errors.js';
+const common = [
+    'no-open',
+    'json',
+    'config',
+    'contract-id',
+    'near-rpc',
+    'base-rpc',
+    'network',
+    'state-dir',
+    'relayer',
+    'trust-contract',
+    'wallet',
+    'evm-key-file',
+    'solana-key-file',
+    'near-key-file',
+    'near-account',
+    'near-public-key',
+    'backup-secret-file',
+];
+const perCommand = {
+    shops: ['search', 'limit', 'offset'],
+    shop: ['id'],
+    catalog: ['shop', 'search', 'limit', 'offset'],
+    fund: [],
+    budget: [],
+    login: [],
+    init: [
+        'signer',
+        'credential-env',
+        'credential-keychain',
+        'agent',
+        'recovery',
+        'key-env',
+        'keychain-entry',
+        'new-key',
+        'daily-budget',
+    ],
+    share: ['resume', 'price', 'shop', 'title', 'description', 'storage-budget', 'listing-storage'],
+    sell: ['resume', 'price', 'split', 'base', 'moderator', 'output', 'storage-budget'],
+    buy: [
+        'force',
+        'origin',
+        'route',
+        'from-chain',
+        'from-asset',
+        'refund-to',
+        'recovery',
+        'max-price',
+        'moderator',
+        'url',
+    ],
+    open: ['purchase', 'file', 'url', 'output'],
+    recover: ['recovery', 'purchase'],
+    stop: [],
+    verify: [],
+    status: [],
+};
+export function parseCli(argv) {
+    try {
+        const keys = [...new Set([...common, ...Object.values(perCommand).flat()])];
+        const booleans = ['json', 'trust-contract', 'base', 'agent', 'no-open', 'new-key', 'force'];
+        const parsed = parseArgs({
+            args: argv,
+            allowPositionals: true,
+            strict: true,
+            options: Object.fromEntries(keys.map((k) => [k, { type: booleans.includes(k) ? 'boolean' : 'string' }])),
+        });
+        const [command, target, ...extra] = parsed.positionals;
+        if (!command ||
+            !(command in perCommand) ||
+            (command === 'fund' || command === 'shop' ? extra.length !== 1 : extra.length !== 0))
+            throw usage();
+        const cmd = command;
+        if ((['recover', 'login', 'init', 'shops', 'catalog'].includes(cmd) && target !== undefined) ||
+            (!['recover', 'login', 'init', 'shops', 'catalog'].includes(cmd) && !target))
+            throw usage();
+        if (cmd === 'shop' && target !== 'add')
+            throw usage();
+        const allowed = [...common, ...perCommand[cmd]];
+        if (Object.keys(parsed.values).some((k) => !allowed.includes(k)))
+            throw usage();
+        const values = Object.fromEntries(Object.entries(parsed.values).map(([k, v]) => [
+            k.replace(/-([a-z])/g, (_, c) => c.toUpperCase()),
+            v,
+        ]));
+        for (const key of ['limit', 'offset']) {
+            if (values[key] !== undefined) {
+                if (typeof values[key] !== 'string' || !/^(0|[1-9][0-9]*)$/.test(values[key]))
+                    throw usage();
+                const n = Number(values[key]);
+                if (!Number.isSafeInteger(n) ||
+                    n < (key === 'limit' ? 1 : 0) ||
+                    (key === 'limit' && n > 100))
+                    throw usage();
+                values[key] = n;
+            }
+        }
+        if (cmd === 'share') {
+            if (values.resume
+                ? !/^0x[0-9a-f]{64}$/.test(String(values.resume)) ||
+                    ['price', 'title', 'description', 'storageBudget', 'listingStorage'].some((k) => values[k] !== undefined)
+                : !values.price)
+                throw usage();
+        }
+        if (cmd === 'sell') {
+            if (values.resume) {
+                if (!/^0x[0-9a-f]{64}$/.test(String(values.resume)) ||
+                    values.price ||
+                    values.split ||
+                    values.base ||
+                    values.moderator ||
+                    values.storageBudget)
+                    throw usage();
+            }
+            else if (!values.price || !values.split)
+                throw usage();
+        }
+        if (cmd === 'init' && values.agent !== true)
+            throw usage();
+        if (cmd === 'recover' && !values.recovery)
+            throw usage();
+        if (values.route && !['near', 'base', '1click'].includes(String(values.route)))
+            throw usage();
+        if (values.wallet && !['evm', 'solana', 'near'].includes(String(values.wallet)))
+            throw usage();
+        return {
+            command: cmd,
+            ...(target === undefined ? {} : { target: cmd === 'shop' ? extra[0] : target }),
+            ...(cmd === 'fund' ? { fundAmount: extra[0] } : {}),
+            ...values,
+        };
+    }
+    catch {
+        throw usage();
+    }
+}
+const HELP = `annon <command> [options]
+shops [--search <q>] [--limit <n>] [--offset <n>]
+shop add <url> [--id <alias>]
+catalog [--shop <id>] [--search <q>] [--limit <n>] [--offset <n>]
+login [--wallet evm|near] [--no-open]
+init --agent --daily-budget <USDC> [--recovery <kind:id>] [--key-env <name> | --keychain-entry <name> | --new-key | --signer <https origin> (--credential-env <name> | --credential-keychain <name>)]
+share <file> --price <USDC> [--shop <id>] [--title <title>] [--description <text>] [--listing-storage <NEAR>] [--storage-budget <NEAR>]
+share <file> --resume <file-id> [--shop <id>]
+sell <file> --resume <file-id> [--output <PAY2>]
+fund <file-id> <NEAR>
+budget <file-id>
+sell <file> [--storage-budget <NEAR>] --price <USDC> --split <kind:id:bps,...> [--base] [--moderator <account>] [--output <PAY2>]
+buy <url|offer.json> [--route near|base|1click] [--origin <configured name>] [--from-chain <chain>] [--from-asset <1Click asset>] [--refund-to <address>] [--recovery <kind:id>] [--max-price <USDC> or configured cap] [--url <expected resource for offer.json>] [--moderator <trusted account>]
+open <purchase-id|backup|PAY2> [--purchase <id|backup>] [--file <PAY2> | --url <url>] --output <file>
+recover --recovery <kind:id> [--purchase <id>]
+stop <file-id>
+verify <PAY2|url>
+status <purchase-id>
+Common: --json --config <file> --contract-id <account> --near-rpc <url> --base-rpc <url>
+--network <near:mainnet> --state-dir <dir> --relayer <url> --trust-contract
+--wallet evm|solana|near --evm-key-file <file> --solana-key-file <file> --near-key-file <file>
+--near-account <account> --near-public-key <ed25519:key> --backup-secret-file <file>
+Secrets: env ANNON_EVM_PRIVATE_KEY, ANNON_SOLANA_KEYPAIR, ANNON_NEAR_CREDENTIALS,
+ANNON_BACKUP_SECRET (64 hex); or explicitly named files. See packages/annon/CLI.md.
+Exit: 0 success (buy may need deposit), 1 operation failed, 2 arguments/config, 3 trust required, 4 purchase pending.
+`;
+export async function runCli(argv, execute, write) {
+    const json = argv.includes('--json') || argv.includes('--json=true');
+    if (argv.length === 0 || argv.includes('--help')) {
+        write(HELP);
+        return 0;
+    }
+    try {
+        const input = parseCli(argv);
+        const result = await execute(input);
+        if (!json && ['shops', 'catalog', 'share'].includes(input.command)) {
+            const show = (value) => {
+                const r = value;
+                const rules = r.info?.rules ?? r.rules;
+                if (rules)
+                    write(`Shop rules (${r.shop?.manifest ?? r.manifest}):\n${rules.text}`);
+            };
+            show(result);
+            const items = result.items;
+            if (Array.isArray(items))
+                for (const item of items)
+                    show(item);
+        }
+        write(JSON.stringify({ ok: true, result }, null, json ? undefined : 2));
+        return input.command === 'status' &&
+            result &&
+            typeof result === 'object' &&
+            'state' in result &&
+            result.state === 'pending'
+            ? 4
+            : 0;
+    }
+    catch (error) {
+        const safe = publicError(error);
+        write(JSON.stringify({ ok: false, error: safe }, null, json ? undefined : 2));
+        return safe.exitCode;
+    }
+}

package/dist/node/command-context.d.ts

@@ -0,0 +1,82 @@
+/** What one CLI command run shares across the command modules: input, config, wallet and stores. */
+import type { Annon, AnnonOptions } from '../api/annon.js';
+import { getFile, type getPurchase } from '../near/rpc.js';
+import type { EncryptedRecord } from '../pay/backup.js';
+import type { PaymentSummary, PurchaseRecord } from '../pay/purchase.js';
+import type { Store } from '../pay/store.js';
+import type { startBrowserSession } from './browser-login.js';
+import type { Input } from './cli.js';
+import type { Config, TrustPrompt } from './config.js';
+import type { Keychain } from './keychain.js';
+import { type Environment, type LocalWallet, loadWallet } from './wallets.js';
+export interface Dependencies {
+    /** Server-owned policy; never taken from tool arguments. */
+    agent?: boolean;
+    keychain?: Keychain;
+    browser?: typeof startBrowserSession;
+    paymentTerms?: (terms: unknown) => void;
+    browserApprovals?: boolean;
+    sdk?: (options: AnnonOptions) => Pick<Annon, 'fund' | 'sell' | 'buy' | 'open' | 'openTo' | 'recover' | 'stop' | 'store' | 'accept' | 'resumeSell'> & Partial<Pick<Annon, 'share' | 'resumeShare'>>;
+    wallet?: typeof loadWallet;
+    file?: typeof getFile;
+    purchase?: typeof getPurchase;
+    fetch?: typeof fetch;
+    prompt?: TrustPrompt;
+    notify?: (message: string) => void;
+    wait?: (ms: number) => Promise<void>;
+}
+interface Resource {
+    id: string;
+    revision: number;
+    contractId: string;
+    header: string;
+    url?: string;
+}
+type AdapterSdk = ReturnType<NonNullable<Dependencies['sdk']>>;
+/** One command run: its input, the resolved config and the injected dependencies. */
+interface RequestContext {
+    env: Environment;
+    d: Dependencies;
+    fetcher: typeof fetch;
+    wait: (ms: number) => Promise<void>;
+    o: Input;
+    c: Config;
+    /** Set by `fund` and `wallet()`; the relay transport signs with it when it is a NEAR wallet. */
+    selected: LocalWallet | undefined;
+    readListing: (fileId: string) => ReturnType<typeof readListing>;
+    paymentDetails: (load: () => Promise<PurchaseRecord | null | undefined>) => ReturnType<typeof paymentDetails>;
+    pendingSetup: (purchaseId: string) => ReturnType<typeof pendingSetup>;
+    wallet: () => Promise<LocalWallet>;
+}
+/** A command run once the backup secret, the local stores and the SDK are ready. */
+interface CommandSession extends RequestContext {
+    secret: Uint8Array;
+    storeDir: string;
+    rawStore: Store<EncryptedRecord>;
+    resources: Store<Resource>;
+    sdk: AdapterSdk;
+}
+/** The helpers close over the returned object, so they all see the same selected wallet. */
+declare function requestContext(env: Environment, d: Dependencies, fetcher: typeof fetch, wait: (ms: number) => Promise<void>, o: Input, c: Config): RequestContext;
+/** The registered file and the listing its header must match, for the configured deployment. */
+declare function readListing(ctx: RequestContext, fileId: string): Promise<{
+    f: import("../near/rpc.js").FileInfo;
+    listing: {
+        publishedHeaderHash?: string;
+        fileId: string;
+        cipherHash: string;
+        seller: import("../index.js").Identity;
+    };
+}>;
+/** Payment summary of a saved purchase, or nothing when the record is missing or unreadable. */
+declare function paymentDetails(ctx: RequestContext, load: () => Promise<PurchaseRecord | null | undefined>): Promise<{
+    route?: PaymentSummary['route'];
+    payment?: PaymentSummary;
+}>;
+/** A purchase whose acceptance cannot be checked without saved state and the backup secret. */
+declare function pendingSetup(ctx: RequestContext, purchaseId: string): Promise<{
+    purchaseId: string;
+    state: string;
+    next: string;
+}>;
+export { type AdapterSdk, type CommandSession, type RequestContext, type Resource, requestContext };

package/dist/node/command-context.js

@@ -0,0 +1,77 @@
+import { getFile } from '../near/rpc.js';
+import { fail } from './adapter-checks.js';
+import { savedPayment } from './payment-terms.js';
+import { retryGate } from './retry-gate.js';
+import { loadWallet } from './wallets.js';
+/** The helpers close over the returned object, so they all see the same selected wallet. */
+function requestContext(env, d, fetcher, wait, o, c) {
+    const ctx = {
+        env,
+        d,
+        fetcher,
+        wait,
+        o,
+        c,
+        selected: undefined,
+        readListing: (fileId) => readListing(ctx, fileId),
+        paymentDetails: (load) => paymentDetails(ctx, load),
+        pendingSetup: (purchaseId) => pendingSetup(ctx, purchaseId),
+        wallet: () => selectWallet(ctx),
+    };
+    return ctx;
+}
+/** The registered file and the listing its header must match, for the configured deployment. */
+async function readListing(ctx, fileId) {
+    const { c, d } = ctx;
+    const f = await (d.file ?? getFile)(c.nearRpc, c.contractId, fileId);
+    if (!f)
+        return fail('unknown_file', 'No registered file exists at this contract.');
+    if (f.takenDown)
+        return fail('taken_down', 'The file has been taken down.');
+    if (f.terms.network !== c.network || f.terms.contract !== c.contractId)
+        throw new Error('deployment mismatch');
+    return {
+        f,
+        listing: {
+            fileId,
+            cipherHash: f.cipherHash,
+            seller: f.seller,
+            ...(f.headerHash ? { publishedHeaderHash: f.headerHash } : {}),
+        },
+    };
+}
+/** Payment summary of a saved purchase, or nothing when the record is missing or unreadable. */
+async function paymentDetails(ctx, load) {
+    const { c } = ctx;
+    try {
+        const record = await load();
+        if (!record ||
+            record.purchase.contract !== c.contractId ||
+            record.terms.contractId !== c.contractId)
+            return {};
+        const payment = savedPayment(record);
+        return { route: payment.route, payment };
+    }
+    catch {
+        // Optional reporting must not block an accepted purchase or a successful open.
+        return {};
+    }
+}
+/** A purchase whose acceptance cannot be checked without saved state and the backup secret. */
+async function pendingSetup(ctx, purchaseId) {
+    const { c, d } = ctx;
+    if (d.agent)
+        await retryGate({ ...c, purchaseId }).defer('settlement_pending', 30);
+    return {
+        purchaseId,
+        state: 'pending',
+        next: 'Check the payment; configure readable saved state and the matching backup secret to resume Base unlock. 1Click SUCCESS alone is not acceptance.',
+    };
+}
+/** Loads the command's wallet once; later calls reuse it. */
+async function selectWallet(ctx) {
+    const { c, d, env, o } = ctx;
+    ctx.selected ??= await (d.wallet ?? loadWallet)({ ...o, network: c.network }, env, c.nearRpc);
+    return ctx.selected;
+}
+export { requestContext };

package/dist/node/config.d.ts

@@ -0,0 +1,37 @@
+import { type DiscoveryConfig } from '../shops/discovery.js';
+import { type SignerConfig } from './agent.js';
+import type { Input } from './cli.js';
+import type { Environment } from './wallets.js';
+export interface Config extends DiscoveryConfig {
+    signer?: SignerConfig;
+    dailyBudget?: string;
+    agent?: boolean;
+    contractId: string;
+    nearRpc: string;
+    baseRpc: string;
+    network: string;
+    stateDir: string;
+    workDir?: string;
+    relayer?: string;
+    maxPrice?: string;
+    trustContract?: boolean;
+    mpcKey?: string;
+    moderators?: string[];
+    origins?: Record<string, {
+        fromChain: string;
+        fromAsset: string;
+        refundTo?: string;
+        maxSourceAmount?: string;
+        usdcDecimals?: number;
+    }>;
+    allowedResources?: string[];
+    storageBudget?: string;
+    listingStorage?: string;
+    maxProtocolFee?: {
+        fixed: string;
+        bps: number;
+    };
+}
+export declare function loadConfig(o: Input, env: Environment, login?: boolean, forcedAgent?: boolean): Promise<Config>;
+export type TrustPrompt = (description: string) => Promise<boolean>;
+export declare function trustContract(c: Config, explicit: boolean, prompt?: TrustPrompt): Promise<void>;

package/dist/node/config.js

@@ -0,0 +1,189 @@
+import { mkdir, readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { secureUrl } from '../download/download.js';
+import { fileStore } from '../pay/store-node.js';
+import { account, network } from '../settle-near/codec.js';
+import { validateDiscoveryConfig } from '../shops/discovery.js';
+import { agentPolicy, configPath, validateSigner } from './agent.js';
+import { AdapterError } from './errors.js';
+import { resourceAllowed } from './resources.js';
+export async function loadConfig(o, env, login = false, forcedAgent = false) {
+    const pinnedAgent = await agentPolicy(o, env, forcedAgent);
+    try {
+        let file = {};
+        const path = configPath(o, env);
+        try {
+            file = JSON.parse(await readFile(path, 'utf8'));
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        const agent = pinnedAgent || file.agent === true;
+        if (agent &&
+            (typeof file.maxPrice !== 'string' || !/^(0|[1-9][0-9]*)(\.[0-9]{1,6})?$/.test(file.maxPrice)))
+            throw new AdapterError('max_price_required', 'Agent mode requires maxPrice in the pinned config.', 2);
+        const policyEnv = agent && env.ANNON_AGENT !== 'true' ? {} : env;
+        const c = {
+            contractId: o.contractId ?? policyEnv.ANNON_CONTRACT_ID ?? file.contractId ?? '',
+            nearRpc: o.nearRpc ??
+                policyEnv.ANNON_NEAR_RPC ??
+                file.nearRpc ??
+                (login
+                    ? (o.network ?? policyEnv.ANNON_NETWORK ?? file.network ?? 'near:mainnet') ===
+                        'near:testnet'
+                        ? 'https://rpc.testnet.fastnear.com'
+                        : 'https://rpc.mainnet.fastnear.com'
+                    : ''),
+            baseRpc: o.baseRpc ?? policyEnv.ANNON_BASE_RPC ?? file.baseRpc ?? '',
+            network: o.network ?? policyEnv.ANNON_NETWORK ?? file.network ?? 'near:mainnet',
+            stateDir: o.stateDir ??
+                (agent ? undefined : env.ANNON_STATE_DIR) ??
+                file.stateDir ??
+                join(homedir(), '.local', 'share', 'annon'),
+        };
+        Object.assign(c, validateDiscoveryConfig(file));
+        const workDir = (env.ANNON_AGENT === 'true' ? env.ANNON_WORK_DIR : undefined) ?? file.workDir;
+        if (agent && (typeof workDir !== 'string' || !workDir.trim()))
+            throw new AdapterError('work_dir_required', 'Agent mode requires an operator-configured workDir.', 2);
+        if (workDir !== undefined) {
+            if (typeof workDir !== 'string' || !workDir.trim())
+                throw new Error('invalid working directory');
+            c.workDir = workDir;
+        }
+        if (file.maxProtocolFee !== undefined) {
+            const fee = file.maxProtocolFee;
+            if (!fee ||
+                typeof fee.fixed !== 'string' ||
+                !/^(0|[1-9][0-9]*)$/.test(fee.fixed) ||
+                !Number.isSafeInteger(fee.bps) ||
+                fee.bps < 0 ||
+                fee.bps >= 10000)
+                throw new Error('invalid protocol fee ceiling');
+            c.maxProtocolFee = fee;
+        }
+        if (file.listingStorage !== undefined)
+            c.listingStorage = file.listingStorage;
+        if (file.storageBudget !== undefined)
+            c.storageBudget = file.storageBudget;
+        if (file.signer)
+            c.signer = validateSigner(file.signer);
+        if (file.dailyBudget !== undefined) {
+            if (typeof file.dailyBudget !== 'string' ||
+                !/^(0|[1-9][0-9]*)(\.[0-9]{1,6})?$/.test(file.dailyBudget))
+                throw new Error('invalid daily budget');
+            c.dailyBudget = file.dailyBudget;
+        }
+        c.agent = pinnedAgent || file.agent === true;
+        if (file.agent === true && resolve(path) !== resolve(configPath({}, env)))
+            throw new AdapterError('agent_policy', 'Agent configs must be pinned by the launcher environment.', 2);
+        const origins = policyEnv.ANNON_ORIGINS ? JSON.parse(policyEnv.ANNON_ORIGINS) : file.origins;
+        if (origins) {
+            if (typeof origins !== 'object' || Array.isArray(origins))
+                throw new Error('invalid origins');
+            for (const value of Object.values(origins)) {
+                if (!value ||
+                    typeof value.fromChain !== 'string' ||
+                    !value.fromChain ||
+                    typeof value.fromAsset !== 'string' ||
+                    !value.fromAsset.startsWith('nep141:') ||
+                    (value.maxSourceAmount !== undefined &&
+                        (typeof value.maxSourceAmount !== 'string' ||
+                            !/^[1-9][0-9]{0,38}$/.test(value.maxSourceAmount) ||
+                            BigInt(value.maxSourceAmount) >= 2n ** 128n)) ||
+                    (value.usdcDecimals !== undefined &&
+                        (!Number.isSafeInteger(value.usdcDecimals) ||
+                            value.usdcDecimals < 0 ||
+                            value.usdcDecimals > 255)) ||
+                    (value.refundTo !== undefined && (typeof value.refundTo !== 'string' || !value.refundTo)))
+                    throw new Error('invalid origin');
+                if (agent && value.usdcDecimals === undefined && value.maxSourceAmount === undefined)
+                    throw new AdapterError('origin_not_allowed', 'Configure usdcDecimals or maxSourceAmount for every origin.', 2);
+            }
+            c.origins = origins;
+        }
+        const envResources = env.ANNON_ALLOWED_RESOURCES?.split(',');
+        for (const list of [file.allowedResources, envResources]) {
+            if (list !== undefined) {
+                if (!Array.isArray(list))
+                    throw new Error('invalid allowed resources');
+                for (const url of list)
+                    secureUrl(url);
+            }
+        }
+        const allowedResources = agent
+            ? file.allowedResources === undefined
+                ? envResources
+                : envResources === undefined
+                    ? file.allowedResources
+                    : Array.from(new Set(file.allowedResources.flatMap((rule) => envResources
+                        .filter((other) => resourceAllowed([rule], other))
+                        .concat(envResources.some((other) => resourceAllowed([other], rule)) ? [rule] : []))))
+            : (envResources ?? file.allowedResources);
+        if (allowedResources !== undefined)
+            c.allowedResources = allowedResources;
+        const envMax = env.ANNON_MAX_PRICE;
+        const units = (value) => {
+            if (!/^(0|[1-9][0-9]*)(\.[0-9]{1,6})?$/.test(value))
+                throw new Error('invalid price cap');
+            const [whole = '', fraction = ''] = value.split('.');
+            return BigInt(whole) * 1000000n + BigInt(fraction.padEnd(6, '0'));
+        };
+        const maxPrice = agent && envMax !== undefined && file.maxPrice !== undefined
+            ? units(envMax) < units(file.maxPrice)
+                ? envMax
+                : file.maxPrice
+            : (envMax ?? file.maxPrice);
+        if (maxPrice !== undefined)
+            c.maxPrice = maxPrice;
+        c.trustContract =
+            policyEnv.ANNON_TRUST_CONTRACT === undefined
+                ? file.trustContract === true
+                : policyEnv.ANNON_TRUST_CONTRACT === 'true';
+        const moderators = policyEnv.ANNON_MODERATORS?.split(',') ?? file.moderators;
+        if (moderators) {
+            for (const moderator of moderators)
+                account(moderator);
+            c.moderators = moderators;
+        }
+        const mpcKey = policyEnv.ANNON_MPC_KEY ?? file.mpcKey;
+        if (mpcKey)
+            c.mpcKey = mpcKey;
+        const relayer = o.relayer ?? policyEnv.ANNON_RELAYER ?? file.relayer;
+        if (relayer)
+            c.relayer = relayer;
+        if (!login || c.contractId)
+            account(c.contractId);
+        network(c.network);
+        for (const endpoint of [
+            c.nearRpc,
+            ...(c.baseRpc ? [c.baseRpc] : []),
+            ...(c.relayer ? [c.relayer] : []),
+        ]) {
+            const url = secureUrl(endpoint);
+            if (url.username || url.password || url.search || url.hash)
+                throw new Error('endpoint credentials must not appear in prompts');
+        }
+        if (!c.stateDir || typeof c.stateDir !== 'string')
+            throw new Error('missing state directory');
+        return c;
+    }
+    catch (error) {
+        if (error instanceof AdapterError)
+            throw error;
+        throw new AdapterError('invalid_config', 'Set contractId, network and nearRpc (plus baseRpc for Base operations) in the config file, environment or flags. Endpoints must use HTTPS (HTTP only on localhost).', 2);
+    }
+}
+export async function trustContract(c, explicit, prompt) {
+    const dir = join(c.stateDir, 'trust');
+    await mkdir(dir, { recursive: true, mode: 0o700 });
+    const store = fileStore(dir);
+    const id = JSON.stringify([c.network, c.nearRpc, c.contractId]);
+    if (await store.load(id))
+        return;
+    if (!explicit &&
+        !(await prompt?.(`Trust contract ${c.contractId} on ${c.network} via ${c.nearRpc}? This contract controls file key release. Type yes: `)))
+        throw new AdapterError('trust_required', 'Review the configured deployment, then use --trust-contract or trustContract: true. Interactive CLI users can answer the first-use prompt.', 3);
+    await store.compareAndSet(id, null, { id, revision: 0 });
+}