@tangle-network/starter-foundry 0.5.4 → 0.7.2

package/registry/layers/framework/celestia-da/files/cmd/celestia-node/main.go

@@ -0,0 +1,146 @@
+// Minimal Celestia DA client — submits a blob to the local light node and
+// retrieves it at the included height via the JSON-RPC interface.
+//
+// Run:   go run ./cmd/celestia-node
+// Needs: CELESTIA_NODE_AUTH_TOKEN env (see AGENTS.md) and the node running on :26658
+package main
+
+import (
+	"bytes"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"time"
+)
+
+const (
+	rpcURL      = "http://127.0.0.1:26658"
+	namespace   = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABjZGE="
+	httpTimeout = 30 * time.Second
+)
+
+type rpcReq struct {
+	Jsonrpc string `json:"jsonrpc"`
+	ID      int    `json:"id"`
+	Method  string `json:"method"`
+	Params  []any  `json:"params"`
+}
+
+type submitResp struct {
+	Result uint64 `json:"result"`
+	Error  *struct {
+		Code    int    `json:"code"`
+		Message string `json:"message"`
+	} `json:"error"`
+}
+
+type blob struct {
+	Namespace    string `json:"namespace"`
+	Data         string `json:"data"`
+	ShareVersion int    `json:"share_version"`
+	Commitment   string `json:"commitment,omitempty"`
+}
+
+type getAllResp struct {
+	Result []blob `json:"result"`
+	Error  *struct {
+		Code    int    `json:"code"`
+		Message string `json:"message"`
+	} `json:"error"`
+}
+
+func main() {
+	token := os.Getenv("CELESTIA_NODE_AUTH_TOKEN")
+	if token == "" {
+		fmt.Fprintln(os.Stderr, "set CELESTIA_NODE_AUTH_TOKEN (docker compose exec node celestia light auth admin --p2p.network mocha-4)")
+		os.Exit(1)
+	}
+
+	client := &http.Client{Timeout: httpTimeout}
+	payload := []byte("hello from celestia-da")
+	height, err := submitBlob(client, token, payload)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "submit: %v\n", err)
+		os.Exit(1)
+	}
+	fmt.Printf("submitted: included at height %d\n", height)
+
+	blobs, err := getAllBlobs(client, token, height)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "retrieve: %v\n", err)
+		os.Exit(1)
+	}
+	fmt.Printf("retrieved: %d blob(s) at height %d\n", len(blobs), height)
+	for i, b := range blobs {
+		raw, _ := base64.StdEncoding.DecodeString(b.Data)
+		fmt.Printf("  [%d] commitment=%s bytes=%q\n", i, b.Commitment, string(raw))
+	}
+}
+
+func submitBlob(client *http.Client, token string, data []byte) (uint64, error) {
+	b := blob{
+		Namespace:    namespace,
+		Data:         base64.StdEncoding.EncodeToString(data),
+		ShareVersion: 0,
+	}
+	req := rpcReq{
+		Jsonrpc: "2.0",
+		ID:      1,
+		Method:  "blob.Submit",
+		Params:  []any{[]blob{b}, map[string]float64{"gas_price": 0.002}},
+	}
+	var out submitResp
+	if err := call(client, token, req, &out); err != nil {
+		return 0, err
+	}
+	if out.Error != nil {
+		return 0, fmt.Errorf("rpc error %d: %s", out.Error.Code, out.Error.Message)
+	}
+	return out.Result, nil
+}
+
+func getAllBlobs(client *http.Client, token string, height uint64) ([]blob, error) {
+	req := rpcReq{
+		Jsonrpc: "2.0",
+		ID:      2,
+		Method:  "blob.GetAll",
+		Params:  []any{height, []string{namespace}},
+	}
+	var out getAllResp
+	if err := call(client, token, req, &out); err != nil {
+		return nil, err
+	}
+	if out.Error != nil {
+		return nil, fmt.Errorf("rpc error %d: %s", out.Error.Code, out.Error.Message)
+	}
+	return out.Result, nil
+}
+
+func call(client *http.Client, token string, req rpcReq, out any) error {
+	body, err := json.Marshal(req)
+	if err != nil {
+		return err
+	}
+	httpReq, err := http.NewRequest("POST", rpcURL, bytes.NewReader(body))
+	if err != nil {
+		return err
+	}
+	httpReq.Header.Set("Content-Type", "application/json")
+	httpReq.Header.Set("Authorization", "Bearer "+token)
+	resp, err := client.Do(httpReq)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	raw, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+	if resp.StatusCode >= 400 {
+		return fmt.Errorf("http %d: %s", resp.StatusCode, string(raw))
+	}
+	return json.Unmarshal(raw, out)
+}

package/registry/layers/framework/celestia-da/files/config.toml

@@ -0,0 +1,32 @@
+# Celestia light-node config overrides. The container also reads its own
+# config.toml inside the data volume — this file is a committed copy of the
+# knobs this starter actually cares about. To apply: cp config.toml data/config.toml
+
+[RPC]
+  Address = "0.0.0.0"
+  Port = "26658"
+  SkipAuth = false
+
+[P2P]
+  ListenAddresses = ["/ip4/0.0.0.0/tcp/2121"]
+  Network = "mocha-4"
+
+[Header]
+  TrustedHash = ""
+  TrustedPeers = []
+
+[DASer]
+  # Data-availability sampling — how many samples per block to prove DA.
+  SamplingRange = 100
+  ConcurrencyLimit = 16
+
+[State]
+  DefaultKeyName = "my_celes_key"
+  DefaultBackendName = "test"
+
+[Share]
+  # Timeout for fetching shares from peers when answering blob.Get.
+  DiscoveryInterval = "30s"
+
+[Node]
+  StartupTimeout = "2m"

package/registry/layers/framework/celestia-da/files/docker-compose.yml

@@ -0,0 +1,30 @@
+services:
+  node:
+    image: ghcr.io/celestiaorg/celestia-node:v0.21.0-mocha
+    container_name: celestia-da-node
+    restart: unless-stopped
+    command:
+      - celestia
+      - light
+      - start
+      - --core.ip
+      - rpc-mocha.pops.one
+      - --p2p.network
+      - mocha-4
+      - --rpc.addr
+      - 0.0.0.0
+      - --rpc.port
+      - "26658"
+      - --rpc.skip-auth=false
+    environment:
+      NODE_TYPE: light
+      P2P_NETWORK: mocha-4
+    ports:
+      - "127.0.0.1:26658:26658"
+    volumes:
+      - ./data:/home/celestia
+    healthcheck:
+      test: ["CMD", "celestia", "header", "sync-state", "--url", "http://localhost:26658"]
+      interval: 30s
+      timeout: 10s
+      retries: 5

package/registry/layers/framework/celestia-da/files/go.mod

@@ -0,0 +1,3 @@
+module celestia-da-starter
+
+go 1.21

package/registry/layers/framework/celestia-da/files/submit-blob.sh

@@ -0,0 +1,54 @@
+#!/usr/bin/env bash
+# Submit a blob to Celestia and retrieve it in one round-trip via the node RPC.
+#
+# Usage:  bash submit-blob.sh "some message"
+# Env:    CELESTIA_NODE_AUTH_TOKEN (required) — grab with:
+#           docker compose exec node celestia light auth admin --p2p.network mocha-4
+set -euo pipefail
+
+: "${CELESTIA_NODE_AUTH_TOKEN:?set CELESTIA_NODE_AUTH_TOKEN first}"
+
+RPC="http://127.0.0.1:26658"
+NAMESPACE="AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABjZGE="
+PAYLOAD="${1:-hello celestia}"
+
+# Base64-encode the payload (RPC expects base64 for blob.data)
+DATA_B64=$(printf '%s' "$PAYLOAD" | base64 | tr -d '\n')
+
+echo "==> submitting blob to namespace $NAMESPACE"
+SUBMIT_RESP=$(curl -fsS -X POST "$RPC" \
+  -H "Authorization: Bearer $CELESTIA_NODE_AUTH_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d "{
+    \"jsonrpc\": \"2.0\",
+    \"id\": 1,
+    \"method\": \"blob.Submit\",
+    \"params\": [
+      [{
+        \"namespace\": \"$NAMESPACE\",
+        \"data\": \"$DATA_B64\",
+        \"share_version\": 0
+      }],
+      { \"gas_price\": 0.002 }
+    ]
+  }")
+
+HEIGHT=$(printf '%s' "$SUBMIT_RESP" | grep -oE '"result":[0-9]+' | grep -oE '[0-9]+' || true)
+if [ -z "$HEIGHT" ]; then
+  echo "submit failed: $SUBMIT_RESP" >&2
+  exit 1
+fi
+
+echo "==> included at height $HEIGHT"
+echo "==> retrieving..."
+
+curl -fsS -X POST "$RPC" \
+  -H "Authorization: Bearer $CELESTIA_NODE_AUTH_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d "{
+    \"jsonrpc\": \"2.0\",
+    \"id\": 2,
+    \"method\": \"blob.GetAll\",
+    \"params\": [$HEIGHT, [\"$NAMESPACE\"]]
+  }"
+echo

package/registry/layers/framework/celestia-da/manifest.json

@@ -0,0 +1,65 @@
+{
+  "id": "celestia-da",
+  "description": "Celestia DA light-node scaffold — docker-compose for the node, config.toml overrides, submit-blob.sh CLI, and a stdlib Go client that round-trips a blob via JSON-RPC.",
+  "appliesTo": ["celestia-da"],
+  "files": [
+    { "source": "files/docker-compose.yml", "target": "docker-compose.yml" },
+    { "source": "files/config.toml", "target": "config.toml" },
+    { "source": "files/submit-blob.sh", "target": "submit-blob.sh" },
+    { "source": "files/cmd/celestia-node/main.go", "target": "cmd/celestia-node/main.go" },
+    { "source": "files/go.mod", "target": "go.mod" },
+    { "source": "files/go.sum", "target": "go.sum" },
+    { "source": "files/AGENTS.md", "target": "AGENTS.md" }
+  ],
+  "buildHints": {
+    "whenToUse": "Any project that needs a Celestia data-availability layer: modular rollups, sovereign chains, or off-chain data-posting pipelines that must prove DA on the Celestia mocha testnet.",
+    "firstSteps": [
+      "Start the light node: `docker compose up -d` — allow 1-2 minutes for initial header sync.",
+      "Fund the node wallet from the Mocha faucet (address in node logs) — blob.Submit costs TIA gas; without funds you will see `insufficient funds`.",
+      "Export the auth token: `export CELESTIA_NODE_AUTH_TOKEN=$(docker compose exec node celestia light auth admin --p2p.network mocha-4)`",
+      "Run the Go round-trip client: `go run ./cmd/celestia-node` — submits a blob and retrieves it at the returned height.",
+      "Or use the shell script: `bash submit-blob.sh \"my payload\"`"
+    ],
+    "gotchas": [
+      "CELESTIA_NODE_AUTH_TOKEN is per container instance — re-export after any `docker compose down && up` cycle.",
+      "blob.GetAll returns null until the chain head advances past the inclusion height — poll `header.NetworkHead` if GetAll returns empty.",
+      "Namespaces must be exactly 29 bytes: 1 version byte + 28 ID bytes. Version-0 user namespaces require the first 18 ID bytes to be 0x00.",
+      "The Go client uses only stdlib — go.sum is intentionally empty. Do not add external deps without running `go mod tidy`.",
+      "Build the binary with `go build ./cmd/celestia-node` from the project root; the resulting binary is named `celestia-node`."
+    ],
+    "architectureNotes": [
+      "cmd/celestia-node/main.go uses only the Go standard library; go.mod declares the module but has no require entries, and go.sum is empty.",
+      "All RPC calls target 127.0.0.1:26658 via JSON-RPC 2.0 with Bearer token auth — same endpoint for blob.Submit, blob.GetAll, and header queries.",
+      "config.toml is the committed knob reference; copy to data/config.toml inside the Docker volume to apply custom overrides."
+    ],
+    "placeholders": [
+      {
+        "path": "cmd/celestia-node/main.go",
+        "description": "Hardcoded namespace constant and sample payload. Replace the `namespace` constant and `payload` variable in main() with your application's namespace and data."
+      },
+      {
+        "path": "submit-blob.sh",
+        "description": "Uses the same hardcoded NAMESPACE as cmd/celestia-node/main.go. Update NAMESPACE in both files together."
+      }
+    ]
+  },
+  "contextHints": {
+    "commands": [
+      "docker compose up -d",
+      "export CELESTIA_NODE_AUTH_TOKEN=$(docker compose exec node celestia light auth admin --p2p.network mocha-4)",
+      "go run ./cmd/celestia-node",
+      "bash submit-blob.sh \"hello celestia\""
+    ],
+    "entrypoints": [
+      "docker-compose.yml",
+      "cmd/celestia-node/main.go",
+      "submit-blob.sh"
+    ],
+    "preview": null,
+    "extensionPoints": [
+      "cmd/celestia-node/main.go",
+      "config.toml",
+      "docker-compose.yml"
+    ]
+  }
+}

package/registry/layers/framework/crm-backend/files/contacts.ts

@@ -0,0 +1,93 @@
+import type { IncomingMessage, ServerResponse } from 'node:http'
+import { eq } from 'drizzle-orm'
+import { db } from '../db/client.js'
+import { companies, contacts } from '../db/schema.js'
+
+async function readJsonBody(request: IncomingMessage): Promise<unknown> {
+  const chunks: Buffer[] = []
+  for await (const chunk of request) chunks.push(chunk as Buffer)
+  const raw = Buffer.concat(chunks).toString('utf8')
+  return raw ? JSON.parse(raw) : null
+}
+
+export async function createContact(request: IncomingMessage, response: ServerResponse) {
+  const body = (await readJsonBody(request)) as {
+    firstName?: string
+    lastName?: string
+    email?: string
+    phone?: string
+    title?: string
+    companyId?: string
+    ownerUserId?: string
+  } | null
+  if (!body || (!body.email && !body.firstName && !body.lastName)) {
+    response.writeHead(422, { 'content-type': 'application/json' })
+    response.end(JSON.stringify({ error: 'at least one of email / firstName / lastName required' }))
+    return
+  }
+  const [row] = await db
+    .insert(contacts)
+    .values({
+      firstName: body.firstName ?? null,
+      lastName: body.lastName ?? null,
+      email: body.email ?? null,
+      phone: body.phone ?? null,
+      title: body.title ?? null,
+      companyId: body.companyId ?? null,
+      ownerUserId: body.ownerUserId ?? null,
+    })
+    .returning()
+  response.writeHead(201, { 'content-type': 'application/json' })
+  response.end(JSON.stringify(row))
+}
+
+export async function getContact(_request: IncomingMessage, response: ServerResponse, id: string) {
+  const [row] = await db.select().from(contacts).where(eq(contacts.id, id)).limit(1)
+  if (!row) {
+    response.writeHead(404, { 'content-type': 'application/json' })
+    response.end(JSON.stringify({ error: 'contact not found' }))
+    return
+  }
+  response.writeHead(200, { 'content-type': 'application/json' })
+  response.end(JSON.stringify(row))
+}
+
+export async function createCompany(request: IncomingMessage, response: ServerResponse) {
+  const body = (await readJsonBody(request)) as {
+    name?: string
+    domain?: string
+    industry?: string
+    sizeRange?: string
+    website?: string
+    ownerUserId?: string
+  } | null
+  if (!body?.name) {
+    response.writeHead(422, { 'content-type': 'application/json' })
+    response.end(JSON.stringify({ error: 'name required' }))
+    return
+  }
+  const [row] = await db
+    .insert(companies)
+    .values({
+      name: body.name,
+      domain: body.domain ?? null,
+      industry: body.industry ?? null,
+      sizeRange: body.sizeRange ?? null,
+      website: body.website ?? null,
+      ownerUserId: body.ownerUserId ?? null,
+    })
+    .returning()
+  response.writeHead(201, { 'content-type': 'application/json' })
+  response.end(JSON.stringify(row))
+}
+
+export async function getCompany(_request: IncomingMessage, response: ServerResponse, id: string) {
+  const [row] = await db.select().from(companies).where(eq(companies.id, id)).limit(1)
+  if (!row) {
+    response.writeHead(404, { 'content-type': 'application/json' })
+    response.end(JSON.stringify({ error: 'company not found' }))
+    return
+  }
+  response.writeHead(200, { 'content-type': 'application/json' })
+  response.end(JSON.stringify(row))
+}

package/registry/layers/framework/crm-backend/files/db.ts

@@ -0,0 +1,8 @@
+import postgres from 'postgres'
+import { drizzle } from 'drizzle-orm/postgres-js'
+import * as schema from './schema.js'
+
+const url = process.env.DATABASE_URL
+if (!url) throw new Error('DATABASE_URL is required')
+const client = postgres(url, { ssl: 'prefer', max: 10 })
+export const db = drizzle(client, { schema })

package/registry/layers/framework/crm-backend/files/drizzle.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'drizzle-kit'
+
+export default defineConfig({
+  schema: './src/db/schema.ts',
+  out: './drizzle',
+  dialect: 'postgresql',
+  dbCredentials: { url: process.env.DATABASE_URL ?? '' },
+  strict: true,
+})

package/registry/layers/framework/crm-backend/files/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "{{packageName}}",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "node --watch --experimental-strip-types src/server.ts",
+    "start": "node --experimental-strip-types src/server.ts",
+    "typecheck": "tsc --noEmit",
+    "validate": "node validate-crm.mjs",
+    "db:generate": "drizzle-kit generate",
+    "db:migrate": "drizzle-kit migrate"
+  },
+  "dependencies": {
+    "drizzle-orm": "^0.36.0",
+    "postgres": "^3.4.5"
+  },
+  "devDependencies": {
+    "drizzle-kit": "^0.30.0",
+    "typescript": "^5.9.0",
+    "@types/node": "^20.17.0"
+  }
+}

package/registry/layers/framework/crm-backend/files/pipeline.ts

@@ -0,0 +1,158 @@
+// Deal pipeline operations. Moving a deal writes a DealStageHistory row so
+// velocity reports (avg days per stage) are possible. Transitioning into a
+// closedWon / closedLost stage also flips the Deal.status + timestamps.
+import type { IncomingMessage, ServerResponse } from 'node:http'
+import { eq } from 'drizzle-orm'
+import { db } from '../db/client.js'
+import { dealStageHistory, deals, stages, activities } from '../db/schema.js'
+
+async function readJsonBody(request: IncomingMessage): Promise<unknown> {
+  const chunks: Buffer[] = []
+  for await (const chunk of request) chunks.push(chunk as Buffer)
+  const raw = Buffer.concat(chunks).toString('utf8')
+  return raw ? JSON.parse(raw) : null
+}
+
+export async function createDeal(request: IncomingMessage, response: ServerResponse) {
+  const body = (await readJsonBody(request)) as {
+    title?: string
+    amountCents?: number
+    currency?: string
+    stageId?: string
+    contactId?: string
+    companyId?: string
+    ownerUserId?: string
+    expectedCloseAt?: string
+  } | null
+  if (!body?.title || !body.stageId) {
+    response.writeHead(422, { 'content-type': 'application/json' })
+    response.end(JSON.stringify({ error: 'title and stageId required' }))
+    return
+  }
+  if (body.amountCents !== undefined && !Number.isInteger(body.amountCents)) {
+    response.writeHead(422, { 'content-type': 'application/json' })
+    response.end(JSON.stringify({ error: 'amountCents must be an integer' }))
+    return
+  }
+  const [row] = await db
+    .insert(deals)
+    .values({
+      title: body.title,
+      amountCents: body.amountCents ?? 0,
+      currency: body.currency ?? 'USD',
+      stageId: body.stageId,
+      contactId: body.contactId ?? null,
+      companyId: body.companyId ?? null,
+      ownerUserId: body.ownerUserId ?? null,
+      expectedCloseAt: body.expectedCloseAt ? new Date(body.expectedCloseAt) : null,
+    })
+    .returning()
+  if (!row) throw new Error('Record not found')
+  // Record initial stage in history
+  await db.insert(dealStageHistory).values({
+    dealId: row.id,
+    fromStageId: null,
+    toStageId: row.stageId,
+    movedByUserId: body.ownerUserId ?? null,
+  })
+  response.writeHead(201, { 'content-type': 'application/json' })
+  response.end(JSON.stringify(row))
+}
+
+export async function moveDealStage(
+  request: IncomingMessage,
+  response: ServerResponse,
+  dealId: string,
+) {
+  const body = (await readJsonBody(request)) as {
+    toStageId?: string
+    movedByUserId?: string
+    notes?: string
+    lostReason?: string
+  } | null
+  if (!body?.toStageId) {
+    response.writeHead(422, { 'content-type': 'application/json' })
+    response.end(JSON.stringify({ error: 'toStageId required' }))
+    return
+  }
+
+  const result = await db.transaction(async (tx) => {
+    const [deal] = await tx.select().from(deals).where(eq(deals.id, dealId)).limit(1)
+    if (!deal) throw new Error('NOT_FOUND')
+    if (deal.status !== 'open') {
+      throw new Error('CLOSED_DEAL_IMMUTABLE')
+    }
+    const [toStage] = await tx.select().from(stages).where(eq(stages.id, body.toStageId!)).limit(1)
+    if (!toStage) throw new Error('STAGE_NOT_FOUND')
+
+    const now = new Date()
+    const update: Partial<typeof deals.$inferInsert> = {
+      stageId: toStage.id,
+      updatedAt: now,
+    }
+    if (toStage.isClosedWon) {
+      update.status = 'won'
+      update.wonAt = now
+    } else if (toStage.isClosedLost) {
+      update.status = 'lost'
+      update.lostAt = now
+      if (body.lostReason) update.lostReason = body.lostReason
+    }
+
+    const [updated] = await tx.update(deals).set(update).where(eq(deals.id, dealId)).returning()
+    await tx.insert(dealStageHistory).values({
+      dealId,
+      fromStageId: deal.stageId,
+      toStageId: toStage.id,
+      movedByUserId: body.movedByUserId ?? null,
+      notes: body.notes ?? null,
+    })
+    return updated
+  }).catch((err) => err as Error)
+
+  if (result instanceof Error) {
+    const map: Record<string, number> = {
+      NOT_FOUND: 404,
+      STAGE_NOT_FOUND: 422,
+      CLOSED_DEAL_IMMUTABLE: 409,
+    }
+    response.writeHead(map[result.message] ?? 500, { 'content-type': 'application/json' })
+    response.end(JSON.stringify({ error: result.message }))
+    return
+  }
+  response.writeHead(200, { 'content-type': 'application/json' })
+  response.end(JSON.stringify(result))
+}
+
+export async function logActivity(request: IncomingMessage, response: ServerResponse) {
+  const body = (await readJsonBody(request)) as {
+    type?: 'call' | 'email' | 'meeting' | 'note' | 'task'
+    occurredAt?: string
+    summary?: string
+    body?: string
+    contactId?: string
+    companyId?: string
+    dealId?: string
+    ownerUserId?: string
+  } | null
+  if (!body?.type || !body.summary) {
+    response.writeHead(422, { 'content-type': 'application/json' })
+    response.end(JSON.stringify({ error: 'type and summary required' }))
+    return
+  }
+  const [row] = await db
+    .insert(activities)
+    .values({
+      type: body.type,
+      occurredAt: body.occurredAt ? new Date(body.occurredAt) : new Date(),
+      summary: body.summary,
+      body: body.body ?? null,
+      contactId: body.contactId ?? null,
+      companyId: body.companyId ?? null,
+      dealId: body.dealId ?? null,
+      ownerUserId: body.ownerUserId ?? null,
+    })
+    .returning()
+  response.writeHead(201, { 'content-type': 'application/json' })
+  response.end(JSON.stringify(row))
+}