@tangle-network/blueprint-ui 0.3.1 → 0.5.0

package/src/wallet/index.ts

@@ -52,16 +52,27 @@ export {
   NO_WALLET_ADDRESS,
   makeCorrelationId,
   type AccountChanged,
+  type CallJobRequest,
   type ChainChanged,
+  type ChainContext,
   type HandshakeAck,
   type HandshakeRequest,
+  type IframeRequest,
+  type JobInputs,
+  type JobResultEvent,
+  type JobResultStatus,
   type ParentMessage,
   type ReadAccountRequest,
   type ReadAccountResult,
+  type ServiceContextBroadcast,
+  type ServiceContextJob,
+  type ServiceContextOperator,
   type SignMessageRequest,
   type SignMessageResult,
   type SignTransactionRequest,
   type SignTransactionResult,
+  type SignTypedDataRequest,
+  type SignTypedDataResult,
   type SwitchChainRequest,
   type SwitchChainResult,
 } from './parentBridgeProtocol';

package/src/wallet/parentBridgeProtocol.ts

@@ -42,6 +42,37 @@ export type SignTransactionRequest = {
   value?: string;
 };
 
+// EIP-712 typed-data signing for publishers that need to sign custom message
+// shapes — operator envelopes, off-chain attestations, claim proofs, etc.
+// The parent renders the typed-data fields in its approval modal so the user
+// can audit what they're signing. Iframes never see the wallet's signing key
+// or private state.
+//
+// Shape mirrors viem's `signTypedData` argument: `domain` + `types` (without
+// the EIP712Domain entry — viem injects it) + `primaryType` + `message`.
+// Validation on the parent side rejects payloads that are obviously
+// malformed (missing primaryType, types map empty, etc.) but does NOT
+// re-shape the message — the user is the one who decides whether to sign.
+export type SignTypedDataRequest = {
+  kind: 'tangle.app.signTypedData';
+  correlationId: string;
+  chainId: number;
+  domain: Readonly<{
+    name?: string;
+    version?: string;
+    chainId?: number;
+    verifyingContract?: Address;
+    salt?: Hex;
+  }>;
+  /** EIP-712 types map; do NOT include the EIP712Domain entry (the parent
+   * injects it derived from `domain`). */
+  types: Readonly<Record<string, ReadonlyArray<{ name: string; type: string }>>>;
+  /** Top-level type name in `types` whose values appear in `message`. */
+  primaryType: string;
+  /** The actual typed-data values. Shape matches `types[primaryType]`. */
+  message: Readonly<Record<string, unknown>>;
+};
+
 // ─── Parent → Iframe messages ────────────────────────────────────────────────
 
 export type HandshakeAck = {
@@ -71,6 +102,10 @@ export type SignTransactionResult = {
   kind: 'tangle.app.signTransactionResult';
 } & ResultEnvelope<{ txHash: Hex }>;
 
+export type SignTypedDataResult = {
+  kind: 'tangle.app.signTypedDataResult';
+} & ResultEnvelope<{ signature: Hex }>;
+
 export type AccountChanged = {
   kind: 'tangle.app.accountChanged';
   account: Address | null;
@@ -81,14 +116,128 @@ export type ChainChanged = {
   chainId: number;
 };
 
+// ─── Service context (parent → iframe) ──────────────────────────────────────
+//
+// Iframe blueprints embedded by Tangle Cloud need to know which service +
+// blueprint they're rendering for, plus which operators are quoted. The
+// parent broadcasts this on mount and on every change (mode picker swap,
+// new service activation, operator delta). The iframe just reads — it
+// doesn't query the chain itself.
+//
+// The thin-iframe SDK exposes this as `useTangleService()`. Iframes that
+// use the full wagmi connector path can still listen to `serviceContext`
+// for routing convenience.
+
+export type ServiceContextOperator = {
+  readonly address: Address;
+  readonly rpcAddress: string | undefined;
+  readonly status: 'active' | 'inactive' | 'unknown';
+};
+
+export type ServiceContextJob = {
+  readonly index: number;
+  readonly name: string;
+  readonly inputSchema?: unknown;
+};
+
+/**
+ * Chain configuration the parent broadcasts to the iframe along with
+ * service context. Iframes use this to build a `viem` public client for
+ * READ-ONLY queries (`useTanglePublicClient` is the convenience hook).
+ *
+ * Iframes can ignore this and roll their own RPC config — particularly
+ * when they need to read from chains OTHER than the active one (e.g. a
+ * trading dapp pulling oracle data from mainnet while the active service
+ * lives on Base Sepolia). The injected client is a hint, not a constraint.
+ *
+ * `rpcUrl` is the public RPC the parent uses, NOT a wallet RPC. Iframes
+ * cannot sign or submit with this URL; signing always routes upstream via
+ * the bridge.
+ */
+export type ChainContext = {
+  readonly id: number;
+  readonly name: string;
+  readonly rpcUrl: string;
+  /** Block-explorer base URL — useful for rendering tx links. */
+  readonly blockExplorerUrl?: string;
+  /** Native currency metadata for cost displays. */
+  readonly nativeCurrency?: { readonly name: string; readonly symbol: string; readonly decimals: number };
+};
+
+export type ServiceContextBroadcast = {
+  kind: 'tangle.app.serviceContext';
+  readonly blueprintId: string;
+  readonly serviceId: string | null;
+  readonly operators: readonly ServiceContextOperator[];
+  readonly jobs: readonly ServiceContextJob[];
+  readonly mode: string | null;
+  /** Active chain the parent is connected to; iframes can build a viem
+   * publicClient against this for convenience. Optional for backwards
+   * compatibility with parents that haven't been upgraded yet. */
+  readonly chain?: ChainContext;
+};
+
+// ─── Job invocation (iframe ↔ parent) ────────────────────────────────────────
+//
+// Instead of the iframe wiring up its own EIP-712 quote / sign / submit
+// flow, it sends a single CallJob request upstream. The parent does the
+// whole dance (fetch RFQ quote, build typed data, request user signature,
+// submit on-chain) and streams results back. The iframe never touches
+// chain logic.
+
+export type JobInputs = Readonly<Record<string, unknown>>;
+
+export type CallJobRequest = {
+  kind: 'tangle.app.callJob';
+  correlationId: string;
+  /** Job index within the blueprint, e.g. 0 for the primary entry-point. */
+  jobIndex: number;
+  /** Free-form inputs validated by the parent against the on-chain ABI. */
+  inputs: JobInputs;
+  /**
+   * Whether the publisher wants intermediate progress (streaming chunks)
+   * or just the terminal result. Streaming jobs (LLM generation, video
+   * encode) opt in; one-shots (embeddings, classifications) don't.
+   */
+  stream?: boolean;
+};
+
+export type JobResultStatus = 'pending' | 'streaming' | 'success' | 'error';
+
+export type JobResultEvent = {
+  kind: 'tangle.app.jobResult';
+  correlationId: string;
+  status: JobResultStatus;
+  /** Present on `streaming` and `success`. Shape is publisher-defined. */
+  data?: unknown;
+  /** Present on `streaming` only — incremental chunk for live UI. */
+  chunk?: unknown;
+  /** Present on `error`. Human-readable. */
+  error?: string;
+  /** Optional progress metadata (e.g. `{ percent: 0.42, eta_ms: 8000 }`). */
+  progress?: { readonly percent?: number; readonly eta_ms?: number };
+};
+
 export type ParentMessage =
   | HandshakeAck
   | ReadAccountResult
   | SwitchChainResult
   | SignMessageResult
   | SignTransactionResult
+  | SignTypedDataResult
   | AccountChanged
-  | ChainChanged;
+  | ChainChanged
+  | ServiceContextBroadcast
+  | JobResultEvent;
+
+export type IframeRequest =
+  | HandshakeRequest
+  | ReadAccountRequest
+  | SwitchChainRequest
+  | SignMessageRequest
+  | SignTransactionRequest
+  | SignTypedDataRequest
+  | CallJobRequest;
 
 // The zero address used by the parent when no wallet is connected. The parent
 // always responds to readAccount with an address; this sentinel means "no

package/src/wallet/parentBridgeProvider.ts

@@ -15,6 +15,10 @@ import {
   NO_WALLET_ADDRESS,
   TANGLE_IFRAME_PROTOCOL_VERSION,
   type ParentMessage,
+  type ReadAccountResult,
+  type SignMessageResult,
+  type SignTransactionResult,
+  type SwitchChainResult,
 } from './parentBridgeProtocol';
 
 type EventName = 'accountsChanged' | 'chainChanged' | 'connect' | 'disconnect' | 'message';
@@ -316,7 +320,19 @@ export class ParentBridgeProvider {
     });
   }
 
-  private resolvePending(message: Extract<ParentMessage, { correlationId: string }>): void {
+  /**
+   * 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(
+    message:
+      | ReadAccountResult
+      | SwitchChainResult
+      | SignMessageResult
+      | SignTransactionResult,
+  ): void {
     const entry = this.pending.get(message.correlationId);
     if (!entry) return;
     this.pending.delete(message.correlationId);