ton-mesh-harness 0.13.0

package/dist/network.d.ts

@@ -0,0 +1,5 @@
+export interface NetworkConfig {
+    tonapiUrl: string;
+    daemonConfigUrl: string;
+}
+export declare function getNetworkConfig(testnet?: boolean): NetworkConfig;

package/dist/sdk/abort.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Tiny AbortSignal → ERR_CANCELLED bridge. Used at every phase
+ * boundary in long-running async generators (`writeDnsRecord`,
+ * `writeDnsRecordAgentic`) and at race-window checkpoints in
+ * `agenticSignAndSend`.
+ *
+ * Kept in its own file so consumers that don't need any other
+ * dns-helpers / deploy machinery can still get the abort-check
+ * pattern without pulling those in.
+ *
+ * NO `console.*` IN THIS FILE — lint-enforced.
+ */
+/**
+ * Build a `checkAborted()` thunk that throws `ERR_CANCELLED` when the
+ * signal has fired. `message` is included in the error so logs
+ * distinguish which surface the cancel originated from.
+ */
+export declare function makeAbortChecker(signal: AbortSignal | undefined, message: string): () => void;
+/**
+ * Best-effort `controller.abort()` for use in `finally` blocks. Some
+ * runtimes throw on a double-abort or on aborting a controller whose
+ * signal is already aborted; we swallow because the goal is "make sure
+ * dependents stop running" and any further error is noise.
+ */
+export declare function safeAbort(controller: AbortController): void;

package/dist/sdk/agentic-config.d.ts

@@ -0,0 +1,199 @@
+/**
+ * Agentic-wallet config loader for `~/.config/ton/config.json` (the file
+ * `@ton/mcp@alpha` writes via `agentic_start_root_wallet_setup`).
+ *
+ * Spec source: docs/v0.8/mcp-core-requirements.md §NF6 (filesystem-level
+ * compose) + cross-verified against `@ton/mcp@0.1.15-alpha.15`'s
+ * `dist/types/config.d.ts` and `dist/registry/config.d.ts` on 2026-05-11.
+ *
+ * Scope for v0.8.0 GA: this loader ONLY supports `type: "standard"` wallet
+ * entries (mnemonic OR private_key direct sign). `type: "agentic"` entries
+ * (NFT-delegated operator-key signing via the agentic collection contract)
+ * are rejected with a clear error — that path requires the @ton/mcp
+ * collection-contract dance which is out of scope for this release.
+ *
+ * NO `console.*` IN THIS FILE — lint-enforced.
+ */
+import { z } from 'zod';
+export type AgenticNetwork = 'mainnet' | 'testnet';
+export type StandardWalletVersion = 'v5r1' | 'v4r2';
+/** What deploy() asks for. */
+export interface AgenticConfigLookup {
+    /** Override path; falls back to TON_CONFIG_PATH env, then `~/.config/ton/config.json`. */
+    config_path?: string;
+    /** Match by id, name, or address. Empty = use `active_wallet_id`. */
+    wallet_label?: string;
+    /** Filter wallets to this network. */
+    network: AgenticNetwork;
+}
+export interface AgenticConfigSelection {
+    wallet: StoredSelectableWallet;
+    /** Per-network toncenter API key from the config (may be undefined). */
+    toncenter_api_key: string | undefined;
+    /** Resolved config path actually loaded (for diagnostics). */
+    config_path: string;
+}
+declare const StoredStandardWalletSchema: z.ZodEffects<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodLiteral<"standard">;
+    wallet_version: z.ZodEnum<["v5r1", "v4r2"]>;
+    network: z.ZodEnum<["mainnet", "testnet"]>;
+    address: z.ZodString;
+    mnemonic: z.ZodOptional<z.ZodString>;
+    private_key: z.ZodOptional<z.ZodString>;
+    removed: z.ZodOptional<z.ZodBoolean>;
+    removed_at: z.ZodOptional<z.ZodString>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    type: "standard";
+    name: string;
+    id: string;
+    wallet_version: "v5r1" | "v4r2";
+    network: "testnet" | "mainnet";
+    address: string;
+    created_at: string;
+    updated_at: string;
+    mnemonic?: string | undefined;
+    private_key?: string | undefined;
+    removed?: boolean | undefined;
+    removed_at?: string | undefined;
+}, {
+    type: "standard";
+    name: string;
+    id: string;
+    wallet_version: "v5r1" | "v4r2";
+    network: "testnet" | "mainnet";
+    address: string;
+    created_at: string;
+    updated_at: string;
+    mnemonic?: string | undefined;
+    private_key?: string | undefined;
+    removed?: boolean | undefined;
+    removed_at?: string | undefined;
+}>, {
+    type: "standard";
+    name: string;
+    id: string;
+    wallet_version: "v5r1" | "v4r2";
+    network: "testnet" | "mainnet";
+    address: string;
+    created_at: string;
+    updated_at: string;
+    mnemonic?: string | undefined;
+    private_key?: string | undefined;
+    removed?: boolean | undefined;
+    removed_at?: string | undefined;
+}, {
+    type: "standard";
+    name: string;
+    id: string;
+    wallet_version: "v5r1" | "v4r2";
+    network: "testnet" | "mainnet";
+    address: string;
+    created_at: string;
+    updated_at: string;
+    mnemonic?: string | undefined;
+    private_key?: string | undefined;
+    removed?: boolean | undefined;
+    removed_at?: string | undefined;
+}>;
+export type StoredStandardWallet = z.infer<typeof StoredStandardWalletSchema>;
+declare const StoredAgenticWalletSchema: z.ZodEffects<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodLiteral<"agentic">;
+    network: z.ZodEnum<["mainnet", "testnet"]>;
+    address: z.ZodString;
+    owner_address: z.ZodString;
+    operator_private_key: z.ZodOptional<z.ZodString>;
+    operator_public_key: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+    collection_address: z.ZodOptional<z.ZodString>;
+    wallet_nft_index: z.ZodOptional<z.ZodString>;
+    origin_operator_public_key: z.ZodOptional<z.ZodString>;
+    deployed_by_user: z.ZodOptional<z.ZodBoolean>;
+    removed: z.ZodOptional<z.ZodBoolean>;
+    removed_at: z.ZodOptional<z.ZodString>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    type: "agentic";
+    name: string;
+    id: string;
+    network: "testnet" | "mainnet";
+    address: string;
+    created_at: string;
+    updated_at: string;
+    owner_address: string;
+    removed?: boolean | undefined;
+    removed_at?: string | undefined;
+    operator_private_key?: string | undefined;
+    operator_public_key?: string | undefined;
+    source?: string | undefined;
+    collection_address?: string | undefined;
+    wallet_nft_index?: string | undefined;
+    origin_operator_public_key?: string | undefined;
+    deployed_by_user?: boolean | undefined;
+}, {
+    type: "agentic";
+    name: string;
+    id: string;
+    network: "testnet" | "mainnet";
+    address: string;
+    created_at: string;
+    updated_at: string;
+    owner_address: string;
+    removed?: boolean | undefined;
+    removed_at?: string | undefined;
+    operator_private_key?: string | undefined;
+    operator_public_key?: string | undefined;
+    source?: string | undefined;
+    collection_address?: string | undefined;
+    wallet_nft_index?: string | undefined;
+    origin_operator_public_key?: string | undefined;
+    deployed_by_user?: boolean | undefined;
+}>, {
+    type: "agentic";
+    name: string;
+    id: string;
+    network: "testnet" | "mainnet";
+    address: string;
+    created_at: string;
+    updated_at: string;
+    owner_address: string;
+    removed?: boolean | undefined;
+    removed_at?: string | undefined;
+    operator_private_key?: string | undefined;
+    operator_public_key?: string | undefined;
+    source?: string | undefined;
+    collection_address?: string | undefined;
+    wallet_nft_index?: string | undefined;
+    origin_operator_public_key?: string | undefined;
+    deployed_by_user?: boolean | undefined;
+}, {
+    type: "agentic";
+    name: string;
+    id: string;
+    network: "testnet" | "mainnet";
+    address: string;
+    created_at: string;
+    updated_at: string;
+    owner_address: string;
+    removed?: boolean | undefined;
+    removed_at?: string | undefined;
+    operator_private_key?: string | undefined;
+    operator_public_key?: string | undefined;
+    source?: string | undefined;
+    collection_address?: string | undefined;
+    wallet_nft_index?: string | undefined;
+    origin_operator_public_key?: string | undefined;
+    deployed_by_user?: boolean | undefined;
+}>;
+export type StoredNftAgenticWallet = z.infer<typeof StoredAgenticWalletSchema>;
+/** Discriminated union of both supported wallet types. */
+export type StoredSelectableWallet = StoredStandardWallet | StoredNftAgenticWallet;
+export declare function getAgenticConfigPath(override?: string): string;
+export declare function loadAgenticConfig(lookup: AgenticConfigLookup): AgenticConfigSelection;
+export {};

package/dist/sdk/agentic-sign.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Agentic signing — dispatches by `wallet.type`:
+ *
+ *  - `standard`: walletkit's `Signer` + `WalletV5R1Adapter`/`WalletV4R2Adapter`
+ *    (direct sign — operator IS the wallet).
+ *  - `agentic`:  @ton/mcp's `AgenticWalletAdapter` (operator key signs via
+ *    the agentic NFT collection contract on behalf of owner_address; v0.8.x).
+ *
+ * Both adapters implement `WalletAdapter` so the rest of this module is
+ * agnostic to the path — `buildAdapter()` returns the right adapter and
+ * `getSignedSendTransaction → sendBoc` is identical.
+ *
+ * The result is the normalized message hash (`0x<hex>`) returned by
+ * `ApiClientToncenter.sendBoc`, suitable as `dns_tx_hash` (it indexes the
+ * external-in message; explorers resolve to the on-chain tx within seconds).
+ *
+ * NO `console.*` IN THIS FILE — lint-enforced.
+ */
+import type { Address, Cell } from '@ton/core';
+import type { StoredSelectableWallet } from './agentic-config';
+export interface AgenticSignSendInput {
+    wallet: StoredSelectableWallet;
+    toncenter_api_key: string | undefined;
+    messages: Array<{
+        address: Address;
+        amount: bigint;
+        payload: Cell;
+    }>;
+    /**
+     * AbortSignal for the cancel-before-broadcast race window. Checked
+     * after adapter construction and after signing, immediately before
+     * `sendBoc`. Once `sendBoc` is invoked the broadcast is no longer
+     * cancellable from our side.
+     */
+    signal?: AbortSignal;
+}
+export interface AgenticSignSendResult {
+    /** Normalized message hash returned by Toncenter (`0x<hex>`). */
+    message_hash: string;
+    /** Wallet address that sent the batch (user-friendly form). */
+    from_address: string;
+}
+/**
+ * Build adapter → sign → broadcast. The returned `message_hash` is the
+ * normalized external-in hash that explorers / TONAPI resolve to the
+ * actual tx within ~10s. We surface it as `dns_tx_hash`.
+ */
+export declare function agenticSignAndSend(input: AgenticSignSendInput): Promise<AgenticSignSendResult>;

package/dist/sdk/check.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Programmatic environment check — the "did the user's machine actually
+ * have everything we need" probe that powers both the CLI's `doctor`
+ * subcommand and the MCP server's `mesh_check_env` tool.
+ *
+ * Spec: docs/v0.8/mcp-core-requirements.md §F2 / §F3.
+ *
+ * NO `console.*` ANYWHERE IN THIS FILE — lint-enforced (planned [S4]).
+ */
+import type { CheckEnvOptions, CheckEnvResult } from './schemas';
+/**
+ * Pre-flight readiness probe. Returns a structured `CheckEnvResult` per the
+ * F2 zod schema — no IO side effects beyond the network probes the function
+ * documents (TONAPI, TonConnect manifest, dns lookups).
+ *
+ * The CLI's `doctor` subcommand and the MCP `mesh_check_env` tool both
+ * route through here.
+ */
+export declare function checkEnv(opts?: CheckEnvOptions): Promise<CheckEnvResult>;
+/**
+ * Re-export tied to tonutils' assumed UDP port so downstream renderers can
+ * label the "port busy" line with the actual number rather than a magic literal.
+ */
+export declare const TONUTILS_DEFAULT_UDP_PORT = 17555;

package/dist/sdk/deploy.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Programmatic deploy SDK — the seam that powers both the CLI's
+ * `runDeployTonutils` adapter and (future) the MCP server's
+ * `mesh_deploy` tool.
+ *
+ * Spec: docs/v0.8/mcp-core-requirements.md §F2 / §F3 / §F4 / §F5.
+ *
+ * Scope (rc5):
+ *   env_check → daemon_starting → bag_creating → bag_uploaded →
+ *   [awaiting_signature → dns_signing → dns_confirmed → verifying]? →
+ *   done. The DNS phases fire iff `opts.domain` is set, routed through
+ *   writeDnsRecord (TonConnect) or writeDnsRecordAgentic depending on
+ *   wallet.kind. watch + site-auto remain CLI-only orchestration —
+ *   they have no MCP-callable equivalent.
+ *
+ * NO `console.*` ANYWHERE IN THIS FILE — lint-enforced.
+ */
+import { type DeployEvent, type DeployOptions, type DeployResult, type ErrCode, type WalletSpec } from './schemas';
+import { type TonutilsHandle } from '../daemon/tonutils-process';
+export type DeployInput = Omit<Partial<DeployOptions>, 'wallet'> & {
+    source_dir: string;
+    wallet?: string | WalletSpec;
+};
+export interface DeployControl {
+    /**
+     * AbortSignal honoured at every event boundary AND just-after the daemon
+     * spawns. When fired:
+     *  - the SDK kills the daemon (regardless of `keep_alive`);
+     *  - in-flight HTTP calls to the daemon will reject (the daemon is gone);
+     *  - the generator throws `SdkError(ERR_CANCELLED)` with `phase_at_cancel`
+     *    set to the most recent yielded phase (or "env_check" if cancellation
+     *    occurred before any yield).
+     *
+     * Per F4: `may_have_published` is `false` for any cancellation that
+     * occurs before `awaiting_signature` fires. Once that phase yields,
+     * the flag is path-aware:
+     *   - tonconnect: `true` (the QR is shown; user may have approved
+     *     out-of-band by the time we abort)
+     *   - agentic: `dnsBroadcastEnqueued` (set when `dns_signing` fires,
+     *     i.e. after Toncenter accepted the BOC)
+     */
+    signal?: AbortSignal;
+    /**
+     * Internal hook — fires once with the live `TonutilsHandle` immediately
+     * after the daemon spawns. The CLI uses this to capture the real handle
+     * for watch-mode re-uploads (so it can call `tonutilsCreate(handle, …)`
+     * later without needing the SDK to re-spawn).
+     *
+     * MCP consumers should NOT use this hook — the MCP server has no
+     * persistent watch-mode that needs the underlying ChildProcess.
+     *
+     * @internal
+     */
+    onDaemonReady?: (handle: TonutilsHandle) => void;
+}
+export declare class SdkError extends Error {
+    readonly code: ErrCode;
+    readonly severity: 'fatal' | 'recoverable';
+    readonly fixHint?: string;
+    readonly data?: Record<string, unknown>;
+    constructor(code: ErrCode, message: string, options?: {
+        severity?: 'fatal' | 'recoverable';
+        fixHint?: string;
+        data?: Record<string, unknown>;
+    });
+}
+/**
+ * Heuristic mapping from `startTonutilsDaemon` failure messages to F5 codes.
+ * The daemon-process module throws `Error(message)` for several distinct
+ * causes (spawn crash / config gen / port collision / API never came up);
+ * we route them to the right ERR_* code by message inspection.
+ *
+ * @internal Exported for unit tests only. The published SDK surface is
+ * curated in `src/sdk.ts` (which omits this); the `export *` in
+ * `src/sdk/index.ts` is an internal-only bundle, not a published entry.
+ */
+export declare function mapDaemonStartError(err: unknown): SdkError;
+/**
+ * Async-generator deploy SDK. Yields typed `DeployEvent` values in phase
+ * order. The terminal `done` event carries the full `DeployResult`; consumers
+ * can also read it from the generator's return value.
+ *
+ * Daemon lifecycle:
+ *   - Normal `keep_alive: false` success → daemon killed BEFORE yielding
+ *     the `done` event, so consumers reading the terminal event already
+ *     see `seed_status: "stopped"`.
+ *   - Normal `keep_alive: true` success → daemon kept alive; CALLER owns
+ *     the kill. Ownership transfers BEFORE the `done` yield so a consumer
+ *     that breaks at `done` doesn't leak via the generator's `return()`.
+ *   - Cancellation (AbortSignal) → daemon ALWAYS killed; throws ERR_CANCELLED.
+ *   - Error → daemon ALWAYS killed.
+ *
+ * Concurrency: this SDK serialises within a process. A second concurrent
+ * `deploy()` invocation throws `SdkError(ERR_BUSY)` per F5 / spec §3.2.
+ */
+export declare function deploy(rawInput: DeployInput, control?: DeployControl): AsyncGenerator<DeployEvent, DeployResult, void>;

package/dist/sdk/dns-helpers.d.ts

@@ -0,0 +1,158 @@
+/**
+ * Shared helpers for `writeDnsRecord` (TonConnect) and
+ * `writeDnsRecordAgentic`. Both paths converged on the same post-
+ * broadcast pipeline:
+ *
+ *   resolve NFT address → build message batch → broadcast (path-specific)
+ *   → kick off Toncenter tx-hash resolve in parallel → poll TONAPI for
+ *   record propagation → await tx-hash with grace → yield dns_confirmed
+ *   + verifying.
+ *
+ * Only the broadcast step + the awaiting_signature event differ by path
+ * (TonConnect: QR/connector dance; agentic: filesystem-key sign+send).
+ * Everything else was duplicated 2× pre-refactor. This module is the
+ * dedup boundary.
+ *
+ * NO `console.*` IN THIS FILE — lint-enforced.
+ */
+import { Address, type Cell } from '@ton/core';
+import { type TxHashResolution } from './resolve-tx';
+import type { AgenticNetwork } from './agentic-config';
+import type { DeployEvent } from './schemas';
+/**
+ * 0.02 TON per DNS update message. v0.6.2 tuned. See cli/dns.ts for
+ * the field-test rationale (compute fee ~0.0015 TON; 10× buffer).
+ */
+export declare const DNS_UPDATE_AMOUNT_NANO = 20000000n;
+/**
+ * Wraps `getDomainNftAddress` and re-throws TONAPI failures as
+ * `ERR_NO_DOMAIN`. `ownershipFixHint` is appended to the fix_hint so
+ * each path can point at its own wallet source (TonConnect: "signing
+ * wallet"; agentic: "wallet at ${address}").
+ */
+export declare function resolveDomainNftOrThrow(domain: string, testnet: boolean, ownershipFixHint: string): Promise<Address>;
+export interface DnsMessage {
+    address: Address;
+    amount: bigint;
+    payload: Cell;
+}
+/**
+ * Build the `change_dns_record` op batch:
+ *   - always: `storage` record → bag id
+ *   - optional: `site` (ADNL) record → ADNL hex
+ */
+export declare function buildDnsMessageBatch(nftAddress: Address, bagId: string, siteAdnl: string | null | undefined): DnsMessage[];
+/**
+ * Poll TONAPI for storage-record propagation; optionally also poll the
+ * site (ADNL) record. Throws `ERR_DNS_TX_TIMEOUT` if either times out.
+ *
+ * `checkAborted` is called between polls so caller-side aborts
+ * short-circuit the long TONAPI wait.
+ *
+ * `timeoutHint` is appended to the timeout error so each path can
+ * include a path-specific identifier (e.g. agentic includes the
+ * Toncenter message hash).
+ */
+export declare function pollDnsConfirmationOrThrow(args: {
+    domain: string;
+    bagId: string;
+    siteAdnl: string | null | undefined;
+    testnet: boolean;
+    /** Optional — called between polls to short-circuit on caller abort. */
+    checkAborted?: () => void;
+    /**
+     * Optional caller abort signal, threaded into the pollers so a cancellation
+     * mid-poll bails within one interval (and interrupts the sleep) instead of
+     * waiting out the full 5-min/3-min timeout. The poller returns false on
+     * abort; `checkAborted` below then throws ERR_CANCELLED. (#135)
+     */
+    signal?: AbortSignal;
+    /** Optional — when omitted, the inner poller emits its own spinner. */
+    silent?: boolean;
+    timeoutHint: string;
+}): Promise<void>;
+/**
+ * Start a best-effort Toncenter `transactionsByMessage` lookup in the
+ * background. Returns a promise that resolves to the tx hash
+ * (`0x<hex>`) when Toncenter has indexed, or `null` on timeout / error.
+ *
+ * Signal is chained from BOTH the caller's signal AND the internal
+ * abort controller so early generator exit cancels the resolve cleanly.
+ * The internal abort controller is what `finally` aborts to clean up
+ * after success / early consumer break.
+ *
+ * Caller MUST pass the internal `txResolveAbort.signal` so the helper
+ * can wire the chain. Returns the promise wrapped in `.catch(() => null)`
+ * so unhandled rejection is impossible.
+ */
+export declare function kickoffTxHashResolve(args: {
+    messageHashHex: string;
+    network: AgenticNetwork;
+    internalAbortSignal: AbortSignal;
+    callerSignal?: AbortSignal;
+    toncenterApiKey?: string;
+}): Promise<TxHashResolution>;
+/**
+ * Default grace the deploy waits for the parallel Toncenter tx-hash
+ * resolver AFTER TONAPI confirms DNS propagation. Raised from 3s → 15s
+ * (#117): when TONAPI propagates the storage record BEFORE Toncenter
+ * indexes the tx — the inverse of the order `resolve-tx.ts` once assumed —
+ * a 3s grace expired and left `dns_tx_hash` null on fully-successful
+ * deploys. 15s lets Toncenter catch up in the common lagging case while
+ * only ever adding latency to that case (the happy path returns early the
+ * moment the resolver settles). It cannot eliminate the race, so the
+ * tx-hash field stays best-effort / nullable by contract.
+ */
+export declare const TX_HASH_GRACE_MS = 15000;
+/**
+ * After TONAPI confirms DNS propagation, give the tx-hash resolver a grace
+ * period. Returns whatever it has at the cutoff (real hash, or null if
+ * Toncenter is still lagging beyond the grace).
+ */
+export declare function awaitTxHashWithGrace(resolvePromise: Promise<TxHashResolution>, graceMs?: number): Promise<TxHashResolution>;
+/**
+ * Confirm a DNS write, preferring TONAPI propagation but falling back to an
+ * AUTHORITATIVE on-chain check. `pollDnsConfirmationOrThrow` throws
+ * `ERR_DNS_TX_TIMEOUT` when TONAPI's (flaky, cache-lagged) `/dns/resolve`
+ * doesn't reflect the record within its window — yet the write may have landed.
+ *
+ * On that timeout we ask `verifyOnChain()`, which reads the NFT's `storage`
+ * record directly via the `dnsresolve` get-method (`resolveStorageRecordOnChain`)
+ * and returns true iff it equals the deployed bag. This proves the
+ * `change_dns_record` ACTION succeeded — unlike trusting the resolved wallet tx
+ * hash, which only proves the wallet's transaction was indexed (a non-owner
+ * wallet's tx still indexes while the DNS never changes; #119 Codex-P1). Only a
+ * timeout with NO on-chain confirmation surfaces the recoverable error.
+ *
+ * @throws the original `ERR_DNS_TX_TIMEOUT` when TONAPI lagged AND the on-chain
+ *   record does not (yet) match; rethrows any other error unchanged.
+ */
+export declare function confirmDnsWriteOrThrow(args: {
+    poll: () => Promise<void>;
+    txHashResolvePromise: Promise<TxHashResolution>;
+    verifyOnChain: () => Promise<boolean>;
+}): Promise<{
+    txHash: string | null;
+    throttled: boolean;
+    viaChainFallback: boolean;
+}>;
+/**
+ * Build the F3 `verifying` event. The data shape is identical for both
+ * paths (verifier = TONAPI for both); only the human-readable `message`
+ * differs slightly by path, so we expose it as a param.
+ */
+export declare function buildVerifyingEvent(message: string): DeployEvent;
+/**
+ * Build the F3 `awaiting_signature` event for the TonConnect path.
+ * `signing_url` is either the live tonkeeper://... deeplink (fresh
+ * session) or a sentinel for a restored session. Per
+ * `AwaitingSignatureDataSchema.tonconnect`.
+ */
+export declare function buildAwaitingSignatureTonConnect(message: string, signingUrl: string): DeployEvent;
+/**
+ * Build the F3 `awaiting_signature` event for the agentic path. Per
+ * `AwaitingSignatureDataSchema.agentic` — `signing_url` is null
+ * (no QR / external app), `wallet_label` is informational for the
+ * agent's logs.
+ */
+export declare function buildAwaitingSignatureAgentic(message: string, walletLabel: string): DeployEvent;

package/dist/sdk/dns-onchain.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Authoritative ON-CHAIN read of a `.ton` domain's `storage` DNS record, used
+ * to confirm a deploy landed when TONAPI's (flaky, cache-lagged) `/dns/resolve`
+ * propagation poll times out (#119).
+ *
+ * It calls the domain NFT's `dnsresolve` get-method via Toncenter — independent
+ * of TONAPI — and parses the returned `dns_storage_address#7473 bag:bits256`
+ * record. Crucially this verifies the NFT's record itself, NOT the signing
+ * wallet's transaction: a resolved wallet tx only proves the wallet broadcast
+ * was indexed, not that the `change_dns_record` action succeeded (e.g. a
+ * non-owner wallet's tx still indexes while the DNS never changes).
+ *
+ * Encoding proven against masashi-ono0611.ton on 2026-06-26:
+ *   dnsresolve(`\0` slice, sha256("storage")) → (8, dns_storage_address#7473 bag:bits256)
+ *
+ * NO `console.*` IN THIS FILE — lint-enforced.
+ */
+import { Address } from '@ton/core';
+import type { AgenticNetwork } from './agentic-config';
+/**
+ * Resolve the domain NFT's on-chain `storage` record to its bag id (lowercased
+ * 64-hex), or `null` on any error / missing-or-non-storage record. Best-effort:
+ * never throws — the caller treats `null` as "could not confirm on-chain".
+ */
+export declare function resolveStorageRecordOnChain(args: {
+    nftAddress: Address;
+    network: AgenticNetwork;
+    toncenterApiKey?: string;
+}): Promise<string | null>;
+/**
+ * True iff the domain's on-chain `storage` record points at `expectedBag`.
+ * `null`-safe (a failed on-chain read is `false`, never a throw).
+ */
+export declare function storageRecordMatchesOnChain(args: {
+    nftAddress: Address;
+    network: AgenticNetwork;
+    expectedBag: string;
+    toncenterApiKey?: string;
+}): Promise<boolean>;