@tangle-network/blueprint-ui 0.5.5 → 0.5.7

package/dist/tangleIframeClient-C7NFG_Dw.d.ts

@@ -0,0 +1,133 @@
+import { Address, Hex } from 'viem';
+import { h as ServiceContextOperator, g as ServiceContextJob, b as ChainContext, e as JobResultStatus, m as SignTypedDataRequest, J as JobInputs } from './parentBridgeProtocol-BSgLXg9g.js';
+
+type WalletSnapshot = {
+    readonly address: Address | null;
+    readonly chainId: number | null;
+    readonly isConnected: boolean;
+};
+type ServiceSnapshot = {
+    readonly blueprintId: string | null;
+    readonly serviceId: string | null;
+    readonly operators: readonly ServiceContextOperator[];
+    readonly jobs: readonly ServiceContextJob[];
+    readonly mode: string | null;
+    /** Chain context broadcast by the parent — drives `useTanglePublicClient`.
+     * `null` when the parent hasn't sent one (older parent or dev mode). */
+    readonly chain: ChainContext | null;
+};
+type JobInvocation = {
+    readonly correlationId: string;
+    readonly status: JobResultStatus;
+    readonly data?: unknown;
+    readonly chunks: readonly unknown[];
+    readonly error?: string;
+    readonly progress?: {
+        readonly percent?: number;
+        readonly eta_ms?: number;
+    };
+};
+type ClientEventMap = {
+    wallet: WalletSnapshot;
+    service: ServiceSnapshot;
+    job: JobInvocation;
+};
+type Listener<K extends keyof ClientEventMap> = (value: ClientEventMap[K]) => void;
+type TangleIframeClientOptions = {
+    /**
+     * Origin of the parent dapp. The client posts every message with this
+     * exact `targetOrigin` and rejects inbound messages from any other origin.
+     * Pass `'*'` only in dev — production must pin to the real parent
+     * (`https://cloud.tangle.tools` etc.).
+     */
+    parentOrigin: string;
+    /**
+     * Stable identifier for this iframe app. The parent surfaces it in
+     * handshake logs + uses it for permission scoping.
+     */
+    appId: string;
+    /**
+     * Per-request timeout. Defaults to 60s — long enough for a user to
+     * read + approve a signing prompt in the parent. Long-running jobs
+     * stream progress events; the request "completes" only on terminal
+     * status, so the timeout protects against parents that drop replies
+     * entirely.
+     */
+    requestTimeoutMs?: number;
+};
+declare class TangleIframeClient {
+    private readonly options;
+    private wallet;
+    private service;
+    private handshakeAcked;
+    private handshakeWaiters;
+    private installed;
+    private handshakeRetry;
+    private listeners;
+    private pendingJobs;
+    constructor(options: TangleIframeClientOptions);
+    /** Wire the global message listener + initial handshake. Idempotent. */
+    install(): void;
+    uninstall(): void;
+    getWallet(): WalletSnapshot;
+    getService(): ServiceSnapshot;
+    subscribe<K extends keyof ClientEventMap>(event: K, listener: Listener<K>): () => void;
+    /**
+     * Ask the parent dapp to connect a wallet — opening its connect modal if
+     * none is connected. The iframe is sandboxed and cannot reach a wallet
+     * itself, so connection is always delegated to the parent. Resolves with the
+     * connected address (or `null` if the user dismissed without connecting).
+     *
+     * Uses a long timeout (the user is interacting with a modal). Already-
+     * connected parents resolve immediately.
+     */
+    connect(): Promise<Address | null>;
+    signMessage(message: string): Promise<Hex>;
+    sendTransaction(tx: {
+        to: Address;
+        data: Hex;
+        value?: bigint;
+    }): Promise<Hex>;
+    switchChain(chainId: number): Promise<number>;
+    /**
+     * EIP-712 typed-data signing. The parent renders the typed-data fields in
+     * its approval modal; the user audits what they're signing. Use for
+     * operator envelopes, off-chain attestations, anything that needs a
+     * signature outside the standard blueprint-job RFQ flow.
+     *
+     * Shape mirrors viem's `signTypedData` argument. Do not include the
+     * EIP712Domain entry in `types` — the parent injects it from `domain`.
+     */
+    signTypedData(args: {
+        domain: SignTypedDataRequest['domain'];
+        types: SignTypedDataRequest['types'];
+        primaryType: string;
+        message: Readonly<Record<string, unknown>>;
+    }): Promise<Hex>;
+    /**
+     * Invoke a blueprint job. Returns a Promise that resolves on terminal
+     * status (`success` or `error`); subscribe to the `job` event for
+     * intermediate streaming chunks.
+     *
+     * Streaming opt-in: pass `stream: true` if the publisher's job emits
+     * chunks (LLM generation, video encoding). One-shot jobs (embeddings,
+     * classifications) skip the streaming machinery.
+     */
+    callJob(args: {
+        jobIndex: number;
+        inputs: JobInputs;
+        stream?: boolean;
+    }): Promise<JobInvocation>;
+    private clearHandshakeRetry;
+    private postHandshake;
+    private postToParent;
+    private handleParentMessage;
+    private dispatchWallet;
+    private handleJobResult;
+    private updateWallet;
+    private updateService;
+    private emit;
+    private ensureBootstrapped;
+}
+
+export { type ClientEventMap as C, type JobInvocation as J, type ServiceSnapshot as S, TangleIframeClient as T, type WalletSnapshot as W, type TangleIframeClientOptions as a };

package/dist/useRegistrationCommand-Df1mvvwE.d.ts

@@ -0,0 +1,151 @@
+import { Address } from 'viem';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React from 'react';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+
+/**
+ * Blueprint Registry — defines the metadata layer for Tangle blueprints.
+ *
+ * Each blueprint exposes a set of jobs. The registry maps on-chain job IDs
+ * to human-readable metadata: labels, descriptions, categories, form fields,
+ * and pricing info. This enables the UI to render appropriate forms for each
+ * job without procedurally generating UI from raw ABI data.
+ *
+ * Third-party blueprints can register here to appear in the wizard.
+ */
+type JobCategory = 'lifecycle' | 'execution' | 'batch' | 'workflow' | 'ssh' | 'management';
+interface JobFieldDef {
+    name: string;
+    label: string;
+    type: 'text' | 'textarea' | 'number' | 'boolean' | 'select' | 'json' | 'combobox';
+    placeholder?: string;
+    required?: boolean;
+    defaultValue?: string | number | boolean;
+    options?: {
+        label: string;
+        value: string;
+    }[];
+    helperText?: string;
+    /** Minimum allowed value for number fields */
+    min?: number;
+    /** Maximum allowed value for number fields */
+    max?: number;
+    /** Step increment for number fields */
+    step?: number;
+    /** Solidity ABI type for encoding (e.g. 'string', 'uint64', 'bool', 'uint8') */
+    abiType?: string;
+    /** ABI param name if different from `name` (e.g. 'agent_identifier' vs 'agentIdentifier') */
+    abiParam?: string;
+    /** Field is included in ABI encoding but never shown in form (e.g. sidecar_token) */
+    internal?: boolean;
+}
+/** ABI param injected from runtime context, not user input (e.g. sidecar_url, sandbox_id) */
+interface AbiContextParam {
+    abiName: string;
+    abiType: string;
+}
+interface JobDefinition {
+    id: number;
+    name: string;
+    label: string;
+    description: string;
+    category: JobCategory;
+    icon: string;
+    pricingMultiplier: number;
+    /** Fields the user needs to fill for this job */
+    fields: JobFieldDef[];
+    /** Whether this job requires an existing sandbox to target */
+    requiresSandbox: boolean;
+    /** Optional warning shown before submission */
+    warning?: string;
+    /** ABI params prepended from runtime context (e.g. sidecar_url for sandbox jobs) */
+    contextParams?: AbiContextParam[];
+    /** Override for jobs with complex ABI encoding (e.g. nested structs) */
+    customEncoder?: (values: Record<string, unknown>, context?: Record<string, unknown>) => `0x${string}`;
+}
+interface BlueprintDefinition {
+    id: string;
+    name: string;
+    version: string;
+    description: string;
+    icon: string;
+    color: string;
+    /** Contract address per chain ID — resolved at runtime */
+    contracts: Record<number, Address>;
+    /** Supported job definitions */
+    jobs: JobDefinition[];
+    /** Category ordering for the UI */
+    categories: {
+        key: JobCategory;
+        label: string;
+        icon: string;
+    }[];
+}
+declare function registerBlueprint(bp: BlueprintDefinition): void;
+declare function getBlueprint(id: string): BlueprintDefinition | undefined;
+declare function getAllBlueprints(): BlueprintDefinition[];
+declare function getBlueprintJobs(blueprintId: string, category?: JobCategory): JobDefinition[];
+declare function getJobById(blueprintId: string, jobId: number): JobDefinition | undefined;
+
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "link" | "success" | "secondary" | "destructive" | "outline" | "ghost" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | "icon-sm" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function Button({ className, variant, size, asChild, ...props }: React.ComponentProps<'button'> & VariantProps<typeof buttonVariants> & {
+    asChild?: boolean;
+}): react_jsx_runtime.JSX.Element;
+
+type Action = {
+    label: string;
+    href?: string;
+    onClick?: () => void;
+    variant?: React.ComponentProps<typeof Button>['variant'];
+    disabled?: boolean;
+};
+type BlueprintHostHeroProps = {
+    title: string;
+    tagline?: string;
+    description?: string;
+    badges?: string[];
+    actions?: Action[];
+    children?: React.ReactNode;
+    className?: string;
+};
+declare function BlueprintHostHero({ title, tagline, description, badges, actions, children, className, }: BlueprintHostHeroProps): react_jsx_runtime.JSX.Element;
+
+type BlueprintHostPanelProps = {
+    title: string;
+    children: React.ReactNode;
+    className?: string;
+};
+declare function BlueprintHostPanel({ title, children, className, }: BlueprintHostPanelProps): react_jsx_runtime.JSX.Element;
+
+type RegistrationMode = 'cargo-tangle' | 'cast';
+interface RegistrationCommandOptions {
+    blueprintId: bigint;
+    rpcAddress: string;
+    ecdsaPublicKey: string;
+    rpcUrl: string;
+    registrationInputs?: string;
+    mode?: RegistrationMode;
+    /** Contract address for cast mode (defaults to TANGLE_CORE placeholder). */
+    servicesAddress?: string;
+}
+interface RegistrationCommandResult {
+    /** The copy-paste command for the operator to run on their VPS. */
+    command: string;
+    /** A human-readable label for the command type. */
+    label: string;
+    /** The blueprint id as a plain number (for display). */
+    blueprintIdNumber: number;
+}
+/**
+ * Builds the operator registration command string for the given blueprint.
+ * Two modes:
+ * - `cargo-tangle` (default) — the canonical `cargo tangle blueprint register` flow.
+ * - `cast` — raw `cast send` for operators who manage their own keys.
+ */
+declare function useRegistrationCommand(options: RegistrationCommandOptions): RegistrationCommandResult;
+
+export { type AbiContextParam as A, type BlueprintDefinition as B, type JobDefinition as J, type RegistrationCommandOptions as R, BlueprintHostHero as a, type BlueprintHostHeroProps as b, BlueprintHostPanel as c, type BlueprintHostPanelProps as d, type JobCategory as e, type JobFieldDef as f, getAllBlueprints as g, getBlueprint as h, getBlueprintJobs as i, getJobById as j, Button as k, buttonVariants as l, registerBlueprint as r, useRegistrationCommand as u };

package/dist/wallet/index.d.ts

@@ -0,0 +1,134 @@
+export { T as TANGLE_CLOUD_ORIGINS_DEFAULT, d as detectTangleCloudParentOrigin } from '../detectParentOrigin-BYruoIdc.js';
+import * as wagmi from 'wagmi';
+import { CreateConnectorFn } from 'wagmi';
+import { Address } from 'viem';
+export { A as AccountChanged, C as CallJobRequest, a as ChainChanged, b as ChainContext, H as HandshakeAck, c as HandshakeRequest, I as IframeRequest, J as JobInputs, d as JobResultEvent, e as JobResultStatus, N as NO_WALLET_ADDRESS, P as ParentMessage, R as ReadAccountRequest, f as ReadAccountResult, S as ServiceContextBroadcast, g as ServiceContextJob, h as ServiceContextOperator, i as SignMessageRequest, j as SignMessageResult, k as SignTransactionRequest, l as SignTransactionResult, m as SignTypedDataRequest, n as SignTypedDataResult, o as SwitchChainRequest, p as SwitchChainResult, T as TANGLE_IFRAME_PROTOCOL_PREFIX, q as TANGLE_IFRAME_PROTOCOL_VERSION, r as makeCorrelationId } from '../parentBridgeProtocol-BSgLXg9g.js';
+
+interface TangleBlueprintConnectorsOptions {
+    /** App id reported to the parent dapp on handshake (when embedded). */
+    appId: string;
+    /**
+     * Connectors used when running STANDALONE (the app's own domain) — e.g.
+     * `[injected(), walletConnect({ projectId })]`. Ignored when embedded.
+     */
+    standalone: CreateConnectorFn[];
+    /** Extra trusted parent origins (staging / preview deploys). */
+    extraOrigins?: readonly string[];
+    /** Override the bridged-request timeout (ms). */
+    requestTimeoutMs?: number;
+}
+/**
+ * One connector list, two deployment modes — so a blueprint app can ship a
+ * single build that runs both standalone and embedded in Tangle Cloud:
+ *
+ *   - **Embedded** (a trusted Tangle Cloud parent is detected): the
+ *     parent-bridge connector is the *only* connector. The sandboxed iframe
+ *     can't inject a wallet extension, so it inherits / drives the parent's
+ *     wallet over the postMessage bridge — surfacing injected/WalletConnect
+ *     here would just dead-end.
+ *   - **Standalone** (no trusted parent): the app's own `standalone`
+ *     connectors, exactly as a normal dapp.
+ *
+ * The choice is made at runtime from the embedding context, so the same
+ * artifact works in both places with no build flags.
+ *
+ *   createConfig({
+ *     chains,
+ *     transports,
+ *     connectors: tangleBlueprintConnectors({
+ *       appId: 'trading-arena',
+ *       standalone: [injected(), walletConnect({ projectId })],
+ *     }),
+ *   })
+ */
+declare function tangleBlueprintConnectors(options: TangleBlueprintConnectorsOptions): CreateConnectorFn[];
+
+type EventName = 'accountsChanged' | 'chainChanged' | 'connect' | 'disconnect' | 'message';
+type Listener = (...args: unknown[]) => void;
+type ParentBridgeOptions = {
+    /**
+     * Origin of the parent dapp that hosts this iframe. The provider posts to
+     * `window.parent` with this exact origin and rejects inbound messages from
+     * any other origin. Pass `'*'` only in development; production must pin to
+     * the real parent (`https://cloud.tangle.tools` or its develop equivalent).
+     */
+    parentOrigin: string;
+    /**
+     * Stable identifier for this iframe app. The parent includes this in the
+     * handshake ack so dev tooling can correlate logs across the two windows.
+     */
+    appId: string;
+    /**
+     * Optional ms timeout for each bridged request. Defaults to 60 seconds —
+     * long enough for a user to read + approve a signing prompt in the parent.
+     */
+    requestTimeoutMs?: number;
+};
+/**
+ * Detect iframe execution context. When this returns `false` the bridge
+ * connector should not be installed and the host app should fall back to its
+ * normal wallet config (ConnectKit + injected/walletConnect).
+ *
+ * `window.parent !== window` is the most reliable signal that works across
+ * sandbox-iframe contexts where direct property access to parent throws.
+ */
+declare function isRunningInIframe(): boolean;
+/**
+ * EIP-1193 provider backed by the Tangle Cloud iframe protocol. One instance
+ * lives per iframe app; the wagmi connector owns the singleton.
+ */
+declare class ParentBridgeProvider {
+    private readonly options;
+    private listeners;
+    private pending;
+    private cachedAccount;
+    private cachedChainId;
+    private handshakeAcked;
+    private handshakeWaiters;
+    private installed;
+    constructor(options: ParentBridgeOptions);
+    /**
+     * Wire up the global message listener and send the initial handshake.
+     * Idempotent — safe to call repeatedly during reconnect attempts.
+     */
+    install(): void;
+    uninstall(): void;
+    request(req: {
+        method: string;
+        params?: unknown[];
+    }): Promise<unknown>;
+    on(event: EventName, listener: Listener): void;
+    removeListener(event: EventName, listener: Listener): void;
+    private postToParent;
+    private handleParentMessage;
+    private sendReadAccount;
+    /**
+     * Ask the parent to connect a wallet (opening its modal if needed) and wait
+     * for the result. Long timeout — the user is interacting with the modal.
+     */
+    private requestConnect;
+    private requestSignMessage;
+    private requestSignTransaction;
+    private requestSwitchChain;
+    private dispatch;
+    /**
+     * Resolves wallet-shape responses (`{ ok, data | error }`). Job results
+     * use a different envelope (`{ status, data?, chunk?, error? }`) and are
+     * routed through a separate listener registered by `useCallJob` / the SDK
+     * — the provider doesn't double-handle them.
+     */
+    private resolvePending;
+    private ensureBootstrapped;
+    private updateAccount;
+    private updateChainId;
+    private emit;
+    /** Visible for tests + the connector's `getAccounts()` shortcut. */
+    getCachedAccount(): Address | null;
+    /** Visible for tests + the connector's `getChainId()` shortcut. */
+    getCachedChainId(): number | null;
+}
+
+type ParentBridgeConnectorOptions = ParentBridgeOptions;
+declare function parentBridgeConnector(options: ParentBridgeConnectorOptions): wagmi.CreateConnectorFn<ParentBridgeProvider, Record<string, unknown>, Record<string, unknown>>;
+
+export { type ParentBridgeConnectorOptions, type ParentBridgeOptions, ParentBridgeProvider, type TangleBlueprintConnectorsOptions, isRunningInIframe, parentBridgeConnector, tangleBlueprintConnectors };