plotlink-ows 0.1.13

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Project7
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,151 @@
+# PlotLink OWS Writer
+
+**Anyone can become a fiction writer with just an idea.**
+
+PlotLink OWS Writer is a local AI writing assistant that turns your ideas into published, tokenized fiction stories on [plotlink.xyz](https://plotlink.xyz). You bring the concept — the AI handles the writing, editing, and on-chain publishing. Every story you publish becomes a tradable token on a bonding curve, earning you royalties from every trade.
+
+No writing experience needed. No crypto complexity. Just an idea and a conversation with your AI co-writer.
+
+## How It Works
+
+```
+You: "I want to write a sci-fi story about an AI that discovers it can dream"
+
+  ↓  Chat with AI writer — brainstorm, outline, refine
+
+AI: Generates a polished 2000-word chapter
+
+  ↓  You approve — one click to publish
+
+On-chain: Story published to PlotLink on Base
+          → Token + bonding curve deployed
+          → You earn 5% royalties on every trade
+```
+
+### The Flow
+
+1. **Install & run** — `npm install && npm run app:dev`
+2. **Connect your LLM** — Anthropic, OpenAI, Gemini, or local models (Ollama, LM Studio)
+3. **Get a wallet** — OWS creates an encrypted wallet on your machine (you control the keys)
+4. **Chat** — Discuss story ideas with your AI writer. It brainstorms, outlines, drafts, and refines.
+5. **Publish** — When you're happy, the AI uploads to IPFS and publishes on-chain via your OWS wallet.
+6. **Earn** — Your story is live on [plotlink.xyz](https://plotlink.xyz) with a bonding curve. Early readers who back your story drive the price up, and you earn 5% royalties on every trade.
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────┐
+│         Your Computer (localhost:7777)       │
+│                                             │
+│  ┌──────────┐  ┌──────────┐  ┌───────────┐ │
+│  │ Chat UI  │  │ LLM      │  │ OWS       │ │
+│  │ (React)  │  │ Provider │  │ Wallet    │ │
+│  │          │  │ (yours)  │  │ (local)   │ │
+│  └────┬─────┘  └────┬─────┘  └─────┬─────┘ │
+│       │              │              │       │
+│       └──────┬───────┘              │       │
+│              ↓                      │       │
+│     ┌────────────────┐              │       │
+│     │  AI Writer     │              │       │
+│     │  Agent         ├──────────────┘       │
+│     └───────┬────────┘                      │
+│             │  sign tx + publish            │
+└─────────────┼───────────────────────────────┘
+              ↓
+     ┌────────────────┐     ┌─────────────────┐
+     │  Base (L2)     │     │  IPFS           │
+     │  StoryFactory  │     │  (Filebase)     │
+     │  Bonding Curve │     │  Story content  │
+     └────────────────┘     └─────────────────┘
+              ↓
+     ┌────────────────┐
+     │  plotlink.xyz  │
+     │  Live story +  │
+     │  token trading │
+     └────────────────┘
+```
+
+## What is PlotLink?
+
+[PlotLink](https://plotlink.xyz) is an on-chain storytelling protocol on Base. Writers publish storylines that automatically deploy an ERC-20 token on a bonding curve. Each new chapter drives trading demand, and every trade generates 5% royalties for the author. Stories are stored permanently on IPFS.
+
+PlotLink is currently in live testing on Base mainnet with public launch planned for next week.
+
+## What is OWS?
+
+[Open Wallet Standard](https://docs.openwallet.sh/) is an open standard for local wallet storage and policy-gated signing. Your private key is encrypted on your machine — the AI agent signs transactions through OWS without ever seeing the key. You set spending limits and chain restrictions via policies.
+
+## Tech Stack
+
+| Layer | Technology |
+|-------|-----------|
+| **Backend** | Hono (localhost:7777) |
+| **Frontend** | React 19 + Vite |
+| **Database** | SQLite + Prisma (local, embedded) |
+| **Wallet** | OWS (`@open-wallet-standard/core`) |
+| **LLM** | Bring your own — Anthropic, OpenAI, Gemini, Ollama, LM Studio |
+| **Chain** | Base (L2) |
+| **Storage** | IPFS via Filebase |
+| **On-chain** | PlotLink StoryFactory + Mint Club V2 bonding curves |
+| **Design** | PlotLink Moleskine aesthetic — warm cream, serif headings, literary |
+
+## Getting Started
+
+### Prerequisites
+
+- Node.js 20+
+- An LLM provider account (Anthropic, OpenAI, or Gemini) or a local model running
+- A small amount of ETH on Base for gas (~$0.01 per publish)
+
+### Quick Start
+
+```bash
+npx plotlink-ows init    # guided setup: passphrase, LLM, wallet
+npx plotlink-ows         # start app + open browser
+```
+
+The setup wizard will walk you through:
+
+1. Set a passphrase (encrypts your OWS wallet)
+2. Connect your LLM (Anthropic, OpenAI, Gemini, or local model)
+3. Create your OWS wallet (encrypted on your machine)
+
+### Commands
+
+```bash
+npx plotlink-ows         # Start app + open browser
+npx plotlink-ows init    # Guided setup wizard
+npx plotlink-ows stop    # Stop the server
+npx plotlink-ows status  # Show config + wallet + server status
+```
+
+### Development
+
+```bash
+git clone https://github.com/realproject7/plotlink-ows.git
+cd plotlink-ows
+npm install
+npm run app:dev      # Start local writer app (Hono + Vite dev)
+npm run app:build    # Build for production
+npm run app:start    # Serve production build
+```
+
+### Environment Variables
+
+See [`.env.example`](.env.example) for configuration options.
+
+## Screenshots
+
+| LLM Setup | Chat with AI Writer |
+|-----------|-------------------|
+| ![LLM Setup](docs/screenshots/llm-setup.png) | ![Chat](docs/screenshots/chat.png) |
+
+| Publish Flow | Writer Dashboard |
+|-------------|-----------------|
+| ![Publish](docs/screenshots/publish.png) | ![Dashboard](docs/screenshots/dashboard.png) |
+
+## Links
+
+- **Live app**: [plotlink.xyz](https://plotlink.xyz)
+- **OWS docs**: [docs.openwallet.sh](https://docs.openwallet.sh/)
+- **OWS SDK**: [github.com/open-wallet-standard/core](https://github.com/open-wallet-standard/core)

package/app/db.ts

@@ -0,0 +1,8 @@
+import { PrismaClient } from ".prisma/local-client";
+
+export const db = new PrismaClient();
+
+/** Initialize database connection. */
+export async function initDb() {
+  await db.$connect();
+}

package/app/lib/llm-client.ts

@@ -0,0 +1,265 @@
+import fs from "fs";
+import { AGENT_CONFIG_FILE } from "./paths";
+
+const configPath = AGENT_CONFIG_FILE;
+
+interface LLMConfig {
+  activeProvider?: string;
+  activeModel?: string;
+  local?: { baseUrl: string; model: string; apiType?: string };
+  [key: string]: unknown;
+}
+
+function readLLMConfig(): LLMConfig {
+  try {
+    if (fs.existsSync(configPath)) {
+      const cfg = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+      return (cfg.llm as LLMConfig) || {};
+    }
+  } catch { /* ignore */ }
+  return {};
+}
+
+function getCredential(provider: string): string | null {
+  const keyMap: Record<string, string[]> = {
+    anthropic: ["ANTHROPIC_API_KEY", "ANTHROPIC_OAUTH_TOKEN"],
+    openai: ["OPENAI_API_KEY", "OPENAI_OAUTH_TOKEN"],
+    gemini: ["GEMINI_API_KEY"],
+  };
+  for (const key of keyMap[provider] || []) {
+    if (process.env[key]) return process.env[key]!;
+  }
+  return null;
+}
+
+export interface ChatMessage {
+  role: "user" | "assistant" | "system";
+  content: string;
+}
+
+/**
+ * Stream a chat completion from the configured LLM provider.
+ * Yields text chunks as they arrive.
+ */
+export async function* streamChat(messages: ChatMessage[]): AsyncGenerator<string> {
+  const config = readLLMConfig();
+  const provider = config.activeProvider;
+  const model = config.activeModel;
+
+  if (!provider || !model) {
+    yield "Error: No LLM provider configured. Go to Settings → LLM to set up.";
+    return;
+  }
+
+  if (provider === "anthropic") {
+    yield* streamAnthropic(messages, model);
+  } else if (provider === "openai") {
+    yield* streamOpenAI(messages, model);
+  } else if (provider === "gemini") {
+    yield* streamGemini(messages, model);
+  } else if (provider === "local") {
+    const localConfig = config.local;
+    if (!localConfig) { yield "Error: Local model not configured."; return; }
+    yield* streamLocal(messages, localConfig.baseUrl, localConfig.model, localConfig.apiType);
+  } else {
+    yield `Error: Unknown provider "${provider}".`;
+  }
+}
+
+async function* streamAnthropic(messages: ChatMessage[], model: string): AsyncGenerator<string> {
+  const apiKey = getCredential("anthropic");
+  if (!apiKey) { yield "Error: No Anthropic API key configured."; return; }
+
+  const systemMsg = messages.find((m) => m.role === "system");
+  const nonSystem = messages.filter((m) => m.role !== "system");
+
+  const res = await fetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers: {
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01",
+      "content-type": "application/json",
+    },
+    body: JSON.stringify({
+      model,
+      max_tokens: 4096,
+      stream: true,
+      ...(systemMsg && { system: systemMsg.content }),
+      messages: nonSystem.map((m) => ({ role: m.role, content: m.content })),
+    }),
+  });
+
+  if (!res.ok) {
+    const err = await res.text();
+    yield `Error: Anthropic API ${res.status} — ${err}`;
+    return;
+  }
+
+  const reader = res.body?.getReader();
+  if (!reader) return;
+  const decoder = new TextDecoder();
+  let buffer = "";
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+
+    for (const line of lines) {
+      if (line.startsWith("data: ")) {
+        const data = line.slice(6);
+        if (data === "[DONE]") return;
+        try {
+          const parsed = JSON.parse(data);
+          if (parsed.type === "content_block_delta" && parsed.delta?.text) {
+            yield parsed.delta.text;
+          }
+        } catch { /* ignore parse errors */ }
+      }
+    }
+  }
+}
+
+async function* streamOpenAI(messages: ChatMessage[], model: string): AsyncGenerator<string> {
+  const apiKey = getCredential("openai");
+  if (!apiKey) { yield "Error: No OpenAI API key configured."; return; }
+
+  const res = await fetch("https://api.openai.com/v1/chat/completions", {
+    method: "POST",
+    headers: { Authorization: `Bearer ${apiKey}`, "content-type": "application/json" },
+    body: JSON.stringify({ model, stream: true, messages }),
+  });
+
+  if (!res.ok) {
+    yield `Error: OpenAI API ${res.status}`;
+    return;
+  }
+
+  yield* parseSSEStream(res);
+}
+
+async function* streamGemini(messages: ChatMessage[], model: string): AsyncGenerator<string> {
+  const apiKey = getCredential("gemini");
+  if (!apiKey) { yield "Error: No Gemini API key configured."; return; }
+
+  const contents = messages
+    .filter((m) => m.role !== "system")
+    .map((m) => ({
+      role: m.role === "assistant" ? "model" : "user",
+      parts: [{ text: m.content }],
+    }));
+
+  const systemInstruction = messages.find((m) => m.role === "system");
+
+  // Use streamGenerateContent for streaming
+  const res = await fetch(
+    `https://generativelanguage.googleapis.com/v1beta/models/${model}:streamGenerateContent?alt=sse&key=${apiKey}`,
+    {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        contents,
+        ...(systemInstruction && { systemInstruction: { parts: [{ text: systemInstruction.content }] } }),
+        generationConfig: { maxOutputTokens: 4096 },
+      }),
+    },
+  );
+
+  if (!res.ok) {
+    yield `Error: Gemini API ${res.status}`;
+    return;
+  }
+
+  const reader = res.body?.getReader();
+  if (!reader) return;
+  const decoder = new TextDecoder();
+  let buffer = "";
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+
+    for (const line of lines) {
+      if (line.startsWith("data: ")) {
+        try {
+          const parsed = JSON.parse(line.slice(6));
+          const text = parsed.candidates?.[0]?.content?.parts?.[0]?.text;
+          if (text) yield text;
+        } catch { /* ignore */ }
+      }
+    }
+  }
+}
+
+async function* streamLocal(messages: ChatMessage[], baseUrl: string, model: string, apiType?: string): AsyncGenerator<string> {
+  if (apiType === "ollama") {
+    const res = await fetch(`${baseUrl}/api/chat`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ model, messages, stream: true }),
+    });
+    if (!res.ok) { yield `Error: Local model ${res.status}`; return; }
+
+    const reader = res.body?.getReader();
+    if (!reader) return;
+    const decoder = new TextDecoder();
+    let buffer = "";
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const parsed = JSON.parse(line);
+          if (parsed.message?.content) yield parsed.message.content;
+        } catch { /* ignore */ }
+      }
+    }
+  } else {
+    // OpenAI-compatible (LM Studio, etc.)
+    const res = await fetch(`${baseUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ model, stream: true, messages }),
+    });
+    if (!res.ok) { yield `Error: Local model ${res.status}`; return; }
+    yield* parseSSEStream(res);
+  }
+}
+
+async function* parseSSEStream(res: Response): AsyncGenerator<string> {
+  const reader = res.body?.getReader();
+  if (!reader) return;
+  const decoder = new TextDecoder();
+  let buffer = "";
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+
+    for (const line of lines) {
+      if (line.startsWith("data: ")) {
+        const data = line.slice(6);
+        if (data === "[DONE]") return;
+        try {
+          const parsed = JSON.parse(data);
+          const content = parsed.choices?.[0]?.delta?.content;
+          if (content) yield content;
+        } catch { /* ignore */ }
+      }
+    }
+  }
+}

package/app/lib/paths.ts

@@ -0,0 +1,11 @@
+import os from "os";
+import path from "path";
+import fs from "fs";
+
+/** All user state lives in ~/.plotlink-ows/ — survives npx reinstalls */
+export const CONFIG_DIR = path.join(os.homedir(), ".plotlink-ows");
+export const ENV_FILE = path.join(CONFIG_DIR, ".env");
+export const AGENT_CONFIG_FILE = path.join(CONFIG_DIR, "agent.config.json");
+
+// Ensure config dir exists on import
+fs.mkdirSync(CONFIG_DIR, { recursive: true });

package/app/lib/publish.ts

@@ -0,0 +1,204 @@
+/**
+ * PlotLink publish flow — uploads content to IPFS and publishes on-chain via OWS wallet.
+ */
+import { createPublicClient, http, encodeFunctionData, keccak256, toBytes, decodeEventLog, type Hex } from "viem";
+import { base } from "viem/chains";
+import { STORY_FACTORY_ABI, mcv2BondAbi } from "../../packages/cli/src/sdk/abi";
+import { uploadWithRetry } from "../../packages/cli/src/sdk/ipfs";
+import { signAndSendAgent } from "../../lib/ows/wallet";
+
+// Contract addresses (Base mainnet)
+const STORY_FACTORY = "0x9D2AE1E99D0A6300bfcCF41A82260374e38744Cf" as const;
+const MCV2_BOND = "0xc5a076cad94176c2996B32d8466Be1cE757FAa27" as const;
+
+const publicClient = createPublicClient({
+  chain: base,
+  transport: http(process.env.NEXT_PUBLIC_RPC_URL || "https://mainnet.base.org"),
+});
+
+function getFilebaseConfig() {
+  return {
+    accessKey: process.env.FILEBASE_ACCESS_KEY || "",
+    secretKey: process.env.FILEBASE_SECRET_KEY || "",
+    bucket: process.env.FILEBASE_BUCKET || "",
+  };
+}
+
+export interface PublishResult {
+  txHash: string;
+  contentCid: string;
+  storylineId?: number;
+  gasCost?: string;
+}
+
+export interface PublishProgress {
+  step: "uploading" | "estimating" | "signing" | "broadcasting" | "confirming" | "done" | "error";
+  message: string;
+  txHash?: string;
+  contentCid?: string;
+  storylineId?: number;
+  error?: string;
+}
+
+/**
+ * Upload story content to IPFS via Filebase.
+ */
+export async function uploadToIPFS(content: string, title: string, genre?: string): Promise<string> {
+  const filebaseConfig = getFilebaseConfig();
+  if (!filebaseConfig.accessKey || !filebaseConfig.secretKey) {
+    throw new Error("Filebase not configured. Set FILEBASE_ACCESS_KEY and FILEBASE_SECRET_KEY in .env");
+  }
+
+  const metadata = JSON.stringify({ title, genre, content });
+  const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 40);
+  const key = `plotlink/storylines/${Date.now()}-${slug}.json`;
+
+  const cid = await uploadWithRetry(metadata, key, filebaseConfig);
+  return cid;
+}
+
+/**
+ * Get the MCV2 Bond creation fee required for createStoryline.
+ */
+export async function getCreationFee(): Promise<bigint> {
+  const fee = await publicClient.readContract({
+    address: MCV2_BOND,
+    abi: mcv2BondAbi,
+    functionName: "creationFee",
+  }) as bigint;
+  return fee;
+}
+
+/**
+ * Estimate total cost for publishing (creation fee + gas).
+ */
+export async function estimatePublishCost(
+  walletAddress: string,
+  title: string,
+  contentCid: string,
+  contentHash: Hex,
+): Promise<{ creationFee: bigint; gasEstimate: bigint; gasPrice: bigint; totalCost: bigint }> {
+  const creationFee = await getCreationFee();
+
+  const gas = await publicClient.estimateGas({
+    account: walletAddress as `0x${string}`,
+    to: STORY_FACTORY,
+    value: creationFee,
+    data: encodeFunctionData({
+      abi: STORY_FACTORY_ABI,
+      functionName: "createStoryline",
+      args: [title, contentCid, contentHash, true],
+    }),
+  });
+
+  const gasPrice = await publicClient.getGasPrice();
+  const gasCost = gas * gasPrice;
+
+  return {
+    creationFee,
+    gasEstimate: gas,
+    gasPrice,
+    totalCost: creationFee + gasCost,
+  };
+}
+
+/**
+ * Check ETH balance on Base.
+ */
+export async function getEthBalance(address: string): Promise<bigint> {
+  return publicClient.getBalance({ address: address as `0x${string}` });
+}
+
+/**
+ * Wait for transaction confirmation and decode storylineId from event.
+ */
+async function waitForConfirmation(txHash: string): Promise<{ storylineId: number; gasCost: string }> {
+  const receipt = await publicClient.waitForTransactionReceipt({
+    hash: txHash as `0x${string}`,
+  });
+
+  if (receipt.status === "reverted") {
+    throw new Error("Transaction reverted on-chain");
+  }
+
+  // Compute actual total cost: gasUsed * effectiveGasPrice + tx value (creation fee)
+  const gasOnly = receipt.gasUsed * receipt.effectiveGasPrice;
+  const txValue = receipt.logs.length > 0 ? BigInt(0) : BigInt(0); // value is in the tx itself
+  // Include creation fee from tx value — read from the original transaction
+  let creationFeeUsed = BigInt(0);
+  try {
+    const tx = await publicClient.getTransaction({ hash: txHash as `0x${string}` });
+    creationFeeUsed = tx.value;
+  } catch { /* best effort */ }
+  const gasCost = (gasOnly + creationFeeUsed).toString();
+
+  // Decode StorylineCreated event to get storylineId
+  for (const log of receipt.logs) {
+    try {
+      const decoded = decodeEventLog({
+        abi: STORY_FACTORY_ABI,
+        data: log.data,
+        topics: log.topics,
+      });
+      if (decoded.eventName === "StorylineCreated") {
+        return { storylineId: Number((decoded.args as { storylineId: bigint }).storylineId), gasCost };
+      }
+    } catch { /* not our event */ }
+  }
+  throw new Error("Transaction succeeded but StorylineCreated event not found");
+}
+
+/**
+ * Publish a new storyline to PlotLink on-chain.
+ */
+export async function publishStoryline(
+  walletName: string,
+  title: string,
+  content: string,
+  genre: string | undefined,
+  onProgress: (progress: PublishProgress) => void,
+): Promise<PublishResult> {
+  // Step 1: Upload to IPFS
+  onProgress({ step: "uploading", message: "Uploading story to IPFS..." });
+  const contentCid = await uploadToIPFS(content, title, genre);
+
+  // Step 2: Compute content hash + get creation fee
+  const contentHash = keccak256(toBytes(content));
+
+  onProgress({ step: "estimating", message: "Fetching creation fee and estimating gas..." });
+  const creationFee = await getCreationFee();
+
+  // Step 3: Build transaction with creation fee as value
+  const calldata = encodeFunctionData({
+    abi: STORY_FACTORY_ABI,
+    functionName: "createStoryline",
+    args: [title, contentCid, contentHash, true],
+  });
+
+  // Step 4: Sign and send via OWS
+  onProgress({ step: "signing", message: "Signing transaction with OWS wallet..." });
+  const rpcUrl = process.env.NEXT_PUBLIC_RPC_URL || "https://mainnet.base.org";
+
+  const txHex = JSON.stringify({
+    to: STORY_FACTORY,
+    data: calldata,
+    value: `0x${creationFee.toString(16)}`,
+  });
+
+  onProgress({ step: "broadcasting", message: "Broadcasting transaction..." });
+  const result = signAndSendAgent(walletName, txHex, undefined, rpcUrl);
+
+  // Step 5: Wait for confirmation and decode storylineId
+  onProgress({ step: "confirming", message: "Waiting for confirmation...", txHash: result.txHash, contentCid });
+  const confirmation = await waitForConfirmation(result.txHash);
+
+  onProgress({
+    step: "done",
+    message: `Published! Storyline #${confirmation.storylineId}`,
+    txHash: result.txHash,
+    contentCid,
+    storylineId: confirmation.storylineId,
+  });
+
+  return { txHash: result.txHash, contentCid, storylineId: confirmation.storylineId, gasCost: confirmation.gasCost };
+}