create-planet 1.0.2 → 1.0.5

package/README.md

@@ -16,7 +16,7 @@ The interactive setup will ask you for:
 - **Warp links** — URLs of neighboring planets to link to (leave empty for defaults)
 - **Cloudflare worker name** — the name of your Worker on Cloudflare
 
-It will then automatically create the required Cloudflare resources (KV namespace and D1 database) and generate a ready-to-deploy `wrangler.jsonc`.
+It will then generate a ready-to-deploy `wrangler.jsonc` configured with a Durable Object for storage.
 
 ## Prerequisites
 
@@ -45,8 +45,7 @@ my-planet/
 │   └── lib/            # Protocol logic (consensus, crypto, travel)
 ├── public/             # CSS, 3D star map (Three.js), static assets
 ├── scripts/            # Dev utilities (simulate universe, inject DO exports)
-├── schema.sql          # D1 database schema
-├── wrangler.jsonc      # Generated with your worker name, KV ID, D1 ID
+├── wrangler.jsonc      # Generated with your worker name and Durable Object config
 ├── wrangler.dev.jsonc  # Local development config
 └── package.json
 ```

package/index.js

@@ -1,7 +1,14 @@
 #!/usr/bin/env node
 import * as p from "@clack/prompts";
 import { execSync, execFileSync } from "child_process";
-import { cpSync, readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from "fs";
+import {
+  cpSync,
+  readFileSync,
+  writeFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+} from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
 
@@ -39,16 +46,6 @@ const runWrangler = (args) => {
   }
 };
 
-const parseKvId = (output) => {
-  const match = output.match(/"id":\s*"([^"]+)"/);
-  return match?.[1] ?? null;
-};
-
-const parseD1Id = (output) => {
-  const match = output.match(/"uuid":\s*"([^"]+)"/);
-  return match?.[1] ?? null;
-};
-
 const patchConfigTs = (filePath, name, description, warpLinks) => {
   let content = readFileSync(filePath, "utf-8");
 
@@ -95,7 +92,8 @@ const main = async () => {
           message: "Output directory",
           placeholder: "my-planet",
           defaultValue: "my-planet",
-          validate: (v) => (v.trim() ? undefined : "Directory name is required"),
+          validate: (v) =>
+            v.trim() ? undefined : "Directory name is required",
         }),
       planetName: () =>
         p.text({
@@ -165,9 +163,17 @@ const main = async () => {
   s.start("Configuring planet...");
   const configPath = path.join(outDir, "src/lib/config.ts");
   const warpLinks = answers.warpLinks
-    ? answers.warpLinks.split(",").map((u) => u.trim()).filter(Boolean)
+    ? answers.warpLinks
+        .split(",")
+        .map((u) => u.trim())
+        .filter(Boolean)
     : [];
-  patchConfigTs(configPath, answers.planetName, answers.planetDescription, warpLinks);
+  patchConfigTs(
+    configPath,
+    answers.planetName,
+    answers.planetDescription,
+    warpLinks,
+  );
   s.stop("Planet configured.");
 
   // Update package.json name
@@ -176,27 +182,6 @@ const main = async () => {
   pkg.name = answers.workerName;
   writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
 
-  // Create Cloudflare resources
-  s.start("Creating KV namespace...");
-  const kvOutput = runWrangler(["kv", "namespace", "create", "KV", "--json"]);
-  const kvId = parseKvId(kvOutput);
-  if (!kvId) {
-    s.stop("Failed to create KV namespace.");
-    p.note(kvOutput, "Wrangler output");
-    process.exit(1);
-  }
-  s.stop(`KV namespace created: ${kvId}`);
-
-  s.start("Creating D1 database...");
-  const d1Output = runWrangler(["d1", "create", "planet_db", "--json"]);
-  const d1Id = parseD1Id(d1Output);
-  if (!d1Id) {
-    s.stop("Failed to create D1 database.");
-    p.note(d1Output, "Wrangler output");
-    process.exit(1);
-  }
-  s.stop(`D1 database created: ${d1Id}`);
-
   // Write wrangler.jsonc
   s.start("Writing wrangler.jsonc...");
   const wranglerConfig = {
@@ -204,19 +189,10 @@ const main = async () => {
     main: "dist/server/entry.mjs",
     compatibility_date: "2026-03-31",
     assets: { directory: "dist/client", binding: "STATIC_ASSETS" },
-    d1_databases: [
-      {
-        binding: "DB",
-        database_name: "planet_db",
-        database_id: d1Id,
-        migrations_dir: "migrations",
-      },
-    ],
-    kv_namespaces: [{ binding: "KV", id: kvId }],
     durable_objects: {
       bindings: [{ name: "TRAFFIC_CONTROL", class_name: "TrafficControl" }],
     },
-    migrations: [{ tag: "v1", new_classes: ["TrafficControl"] }],
+    migrations: [{ tag: "v1", new_sqlite_classes: ["TrafficControl"] }],
   };
   writeFileSync(
     path.join(outDir, "wrangler.jsonc"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-planet",
-  "version": "1.0.2",
+  "version": "1.0.5",
   "description": "Scaffold a new Federated Planets planet",
   "type": "module",
   "bin": {
@@ -14,6 +14,11 @@
     "sync-template": "node scripts/sync-template.js",
     "prepublishOnly": "node scripts/sync-template.js"
   },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Federated-Planets/planet.git",
+    "directory": "create-planet"
+  },
   "dependencies": {
     "@clack/prompts": "^0.9.0"
   }

package/template/.github/workflows/publish.yml

@@ -5,12 +5,14 @@ on:
     tags:
       - "v*"
 
+permissions:
+  contents: read
+  id-token: write
+
 jobs:
   publish:
     runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      id-token: write
+
     steps:
       - uses: actions/checkout@v4
 
@@ -24,5 +26,5 @@ jobs:
         working-directory: create-planet
 
       - name: Sync template and publish
-        run: npm publish --provenance --access public
+        run: npm publish
         working-directory: create-planet

package/template/AGENTS.md

@@ -15,8 +15,7 @@ Run these commands one after another to make sure they match permissions.
 
 - **Framework:** Astro (SSR mode)
 - **Runtime:** Cloudflare Workers (Note: This is a Worker project, NOT a Pages project)
-- **Database:** Cloudflare D1 (Local state, Mission Archive, Traffic Logs)
-- **State/Cache:** Cloudflare KV (Cryptographic keys, Distributed Ledger cache)
+- **Storage:** Cloudflare Durable Objects with SQLite (Local state, Mission Archive, Traffic Logs, Cryptographic keys, Consensus state)
 - **Validation:** Zod
 - **Hashing:** MD5 (via `md5` package)
 - **Cryptography:** Web Crypto API (Ed25519 signatures)
@@ -28,18 +27,19 @@ Run these commands one after another to make sure they match permissions.
 - Add `space_port` field to `public/manifest.json`.
 - Endpoint: `https://<domain>/api/v1/port`
 
-### 2.2 Database Schema (D1)
+### 2.2 Database Schema (Durable Object SQLite)
 
-Create `schema.sql`:
+Tables are created automatically in the TrafficControl Durable Object constructor:
 
-- `travel_plans`: `id`, `ship_id`, `origin_url`, `destination_url`, `start_timestamp`, `end_timestamp`, `status` (PREPARING, TRANSIT, ARRIVED), `signatures` (JSON array).
-- `mission_archive`: `id`, `ship_id`, `event` (ARRIVED, DEPARTED), `location_name`, `location_url`, `timestamp`.
+- `travel_plans`: `id`, `ship_id`, `origin_url`, `destination_url`, `start_timestamp`, `end_timestamp`, `status` (PREPARING, PLAN_ACCEPTED), `signatures` (JSON).
 - `traffic_controllers`: Cache of known neighbor manifests and their `space_port` status.
+- `identity`: Ed25519 key pair storage.
+- `consensus_plans`: In-flight consensus plan state with expiration.
 
 ### 2.3 Cryptography Utility
 
 - Implement `crypto.ts` to manage the planet's identity.
-- Generate and store an Ed25519 KeyPair in KV if it doesn't exist.
+- Generate and store an Ed25519 KeyPair in Durable Object SQLite if it doesn't exist.
 - Methods for `sign(data)` and `verify(data, signature, publicKey)`.
 
 ## 3. Phase 2: Core Protocol Logic
@@ -70,7 +70,7 @@ Create `schema.sql`:
 
 ### 4.1 Dynamic Star Map
 
-- Update `index.astro` to fetch live traffic from D1.
+- Update `index.astro` to fetch live traffic from the Durable Object.
 - Pass real coordinates from the database to the ThreeJS map.
 
 ### 4.2 Flight Deck

package/template/PROTOCOL_DIAGRAMS.md

@@ -5,22 +5,20 @@ The following diagram illustrates the lifecycle of a travel transaction using th
 ```mermaid
 sequenceDiagram
     participant Traveler as 🚀 Ship Browser
-    participant DO as TrafficControl DO
+    participant DO as TrafficControl DO (SQLite)
     participant Origin as 🌍 Origin Space Port
     participant Dest as 🌍 Destination Space Port
-    participant KV as KV Store
-    participant D1 as D1 Database
     participant TCs as 🌐 Elected Traffic Controllers (3f+1)
 
     Note over Traveler, Dest: PHASE 1: INITIATION & SORTITION
     Traveler->>Origin: POST /initiate (Destination, ShipID)
     par Parallel discovery
-        Origin->>D1: Lookup cached manifests for origin neighbors
-        D1-->>Origin: Origin neighbor manifests
+        Origin->>DO: Lookup cached manifests for origin neighbors
+        DO-->>Origin: Origin neighbor manifests
         opt Cache miss
             Origin->>Dest: Fetch space-manifest link + manifest JSON
             Dest-->>Origin: PlanetManifest (name, landing_site, space_port)
-            Origin->>D1: Store manifest in traffic_controllers cache
+            Origin->>DO: Store manifest in traffic_controllers cache
         end
     and
         Origin->>Dest: GET ?action=neighbors
@@ -30,22 +28,22 @@ sequenceDiagram
     Note over Origin: Mandatory TCs: Origin + Destination
     Note over Origin: Elected TCs: half from origin neighbors, half from dest neighbors
     Origin->>Origin: Elect TCs (seed-based sortition, dedup)
-    Origin->>KV: Read Ed25519 identity keys (identity_public/private)
-    KV-->>Origin: Key pair
+    Origin->>DO: Read Ed25519 identity keys
+    DO-->>Origin: Key pair
     Origin->>Origin: Sign Plan (Ed25519)
-    Origin->>KV: Save consensus plan state (consensus_plan_{id})
+    Origin->>DO: Save consensus plan state
     par Fire-and-forget
         Origin-->>DO: INITIATE_TRAVEL event
     and Parallel POST ×N
         Origin->>TCs: PRE-PREPARE (Signed Plan)
     end
 
-    Note over TCs, KV: PHASE 2: CONSENSUS (PBFT)
+    Note over TCs, DO: PHASE 2: CONSENSUS (PBFT)
     loop Each Traffic Controller
         TCs->>TCs: Verify Plan integrity (coordinates & travel time)
-        TCs->>KV: Read own identity keys
+        TCs->>DO: Read own identity keys
         TCs->>TCs: Sign Plan
-        TCs->>KV: Merge signatures into consensus plan state
+        TCs->>DO: Merge signatures into consensus plan state
         par Fire-and-forget
             TCs-->>DO: PREPARE_PLAN event
         and Parallel POST ×N
@@ -53,17 +51,17 @@ sequenceDiagram
         end
     end
 
-    Note over Origin, D1: PHASE 3: RECORDING & TRANSIT
-    Origin->>KV: Read accumulated signatures (consensus_plan_{id})
+    Note over Origin, DO: PHASE 3: RECORDING & TRANSIT
+    Origin->>DO: Read accumulated signatures
     Origin->>Origin: Check quorum (2f+1 signatures reached)
     Origin->>Dest: POST ?action=register (Approved Plan)
     Dest->>Dest: Verify destination URL
     Dest->>Dest: Verify travel time math
     Dest->>Dest: Verify end_timestamp not expired (anti-cheat)
     Dest->>Dest: Verify quorum (2f+1 signatures)
-    Dest->>D1: Store plan (incoming traffic)
+    Dest->>DO: Store plan (incoming traffic)
     Dest-->>Origin: 200 OK
-    Origin->>D1: Persist Approved Plan (travel_plans, status=PLAN_ACCEPTED)
+    Origin->>DO: Persist Approved Plan (travel_plans, status=PLAN_ACCEPTED)
     Origin->>DO: Broadcast QUORUM_REACHED event
     DO-->>Traveler: WebSocket push (status updates to live UI)
     Origin-->>Traveler: 200 OK (Travel Authorized)
@@ -93,31 +91,36 @@ sequenceDiagram
 
 ## Data Storage
 
-| Store              | Purpose                                                   | Durability                        |
-| ------------------ | --------------------------------------------------------- | --------------------------------- |
-| **D1**             | `travel_plans`, `traffic_controllers` cache               | Persistent                        |
-| **KV**             | Ed25519 identity key pair, in-flight consensus plan state | Persistent (keys), TTL 1h (plans) |
-| **Durable Object** | WebSocket sessions, last-50 event ring buffer             | In-memory only (volatile)         |
+All persistent storage lives in the TrafficControl Durable Object's built-in SQLite database:
+
+| Table                 | Purpose                                          | Durability             |
+| --------------------- | ------------------------------------------------ | ---------------------- |
+| `travel_plans`        | Active and historical journeys                   | Persistent             |
+| `traffic_controllers` | Cached neighbor manifests (1h TTL via timestamp) | Persistent             |
+| `identity`            | Ed25519 key pair                                 | Persistent             |
+| `consensus_plans`     | In-flight consensus plan state                   | Persistent (1h expiry) |
+
+The DO also holds in-memory state: WebSocket sessions and a last-50 event ring buffer (volatile).
 
 ## Plan Data State Diagram
 
-Server-side status stored in `travel_plans.status` (D1) and the in-flight KV plan:
+Server-side status stored in `travel_plans.status` and the in-flight `consensus_plans` table:
 
 ```mermaid
 stateDiagram-v2
     [*] --> PREPARING : Origin creates plan (handleInitiate)
-    PREPARING --> PLAN_ACCEPTED : Quorum reached (2f+1 sigs) (handleCommit → D1 insert)
+    PREPARING --> PLAN_ACCEPTED : Quorum reached (2f+1 sigs) (handleCommit → travel_plans insert)
     PLAN_ACCEPTED --> [*] : end_timestamp passes (no server transition — record kept forever)
 
     note right of PREPARING
-        Stored in KV only
-        (consensus_plan_{id})
+        Stored in consensus_plans table
+        (expires after 1h)
     end note
 
     note right of PLAN_ACCEPTED
-        Persisted to D1 travel_plans
-        Registered at destination (fire-and-forget)
-        KV entry expires after TTL
+        Persisted to travel_plans table
+        Registered at destination
+        consensus_plans entry expires
     end note
 ```
 
@@ -175,21 +178,17 @@ erDiagram
         INTEGER last_manifest_fetch "Unix ms, TTL 1h"
     }
 
-    KV_IDENTITY {
-        TEXT identity_public "Ed25519 public key (Base64)"
-        TEXT identity_private "Ed25519 private key (Base64)"
-    }
-
-    KV_CONSENSUS {
-        TEXT consensus_plan_id PK "consensus_plan_{uuid}"
-        TEXT plan_json "TravelPlan with accumulated sigs"
+    IDENTITY {
+        TEXT key PK "identity_public or identity_private"
+        TEXT value "Ed25519 key (Base64)"
     }
 
-    DO_TRAFFIC_CONTROL {
-        SET sessions "Active WebSocket connections"
-        ARRAY events "Ring buffer: last 50 API events"
+    CONSENSUS_PLANS {
+        TEXT id PK "plan UUID"
+        TEXT data "TravelPlan JSON with accumulated sigs"
+        INTEGER expires_at "Unix ms"
     }
 
-    TRAVEL_PLANS ||--o{ KV_CONSENSUS : "built during PBFT"
+    TRAVEL_PLANS ||--o{ CONSENSUS_PLANS : "built during PBFT"
     TRAVEL_PLANS }o--o{ TRAFFIC_CONTROLLERS : "controllers elected from"
 ```

package/template/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@federated-planets/planet",
-  "version": "1.0.2",
+  "version": "1.0.5",
   "description": "A decentralized space exploration game where every planet is a sovereign website.",
   "scripts": {
     "dev": "npm run build && wrangler dev -c wrangler.dev.jsonc",
-    "dev:db:init": "wrangler d1 execute planet_db --file=schema.sql --local -c wrangler.dev.jsonc",
     "dev:clean": "rm -rf .wrangler/state",
     "format": "prettier --write .",
     "build": "astro build",
     "postbuild": "node scripts/inject-do-exports.js",
     "preview": "wrangler preview",
     "simulate": "node scripts/simulate-universe.js",
+    "simulate:open": "node scripts/simulate-universe.js --open",
     "test": "npm run build && vitest run",
     "test:protocol": "npm run build && vitest run src/tests/protocol.test.ts",
     "test:warp-links": "npm run build && vitest run src/tests/warp-links.test.ts",

package/template/scripts/simulate-universe.js

@@ -34,16 +34,6 @@ const startPlanet = (planet) => {
   const { id, name, url, port } = planet;
   const inspectorPort = BASE_INSPECTOR_PORT + id;
 
-  // Initialize Database first
-  console.log(`[${name}] Initializing database...`);
-  execSync(
-    `npx wrangler d1 execute planet_db --file=schema.sql -c wrangler.dev.jsonc --local --persist-to=.wrangler/state/planet-${id}`,
-    {
-      cwd: path.join(__dirname, ".."),
-      stdio: "inherit",
-    },
-  );
-
   const env = {
     ...process.env,
     PUBLIC_SIM_PLANET_NAME: name,

package/template/src/env.d.ts

@@ -1,8 +1,6 @@
 /// <reference types="astro/client" />
 
 interface ImportMetaEnv {
-  readonly KV: import("@cloudflare/workers-types").KVNamespace;
-  readonly DB: import("@cloudflare/workers-types").D1Database;
   readonly TRAFFIC_CONTROL: import("@cloudflare/workers-types").DurableObjectNamespace;
   readonly PUBLIC_SIM_PLANET_NAME?: string;
   readonly PUBLIC_SIM_PLANET_DESCRIPTION?: string;

package/template/src/lib/config.ts

@@ -8,12 +8,18 @@ export const DEFAULT_WARP_LINKS = [
     name: "Federation Prime",
     url: "https://prime.federatedplanets.com/",
   },
-  { name: "Waystation Meridian", url: "https://waystation.federatedplanets.com/" },
+  {
+    name: "Waystation Meridian",
+    url: "https://waystation.federatedplanets.com/",
+  },
   { name: "The Interchange", url: "https://interchange.federatedplanets.com/" },
   { name: "Port Cassini", url: "https://port-cassini.federatedplanets.com/" },
   { name: "Terminus Reach", url: "https://terminus.federatedplanets.com/" },
   { name: "Driftyard Seven", url: "https://driftyard.federatedplanets.com/" },
-  { name: "Towel 42 Space Outpost", url: "https://towel-42.federatedplanets.com/" },
+  {
+    name: "Towel 42 Space Outpost",
+    url: "https://towel-42.federatedplanets.com/",
+  },
   { name: "Explorers Outpost", url: "https://www.nasa.gov/" },
 ];
 

package/template/src/lib/consensus.ts

@@ -2,6 +2,7 @@ import { CryptoCore } from "./crypto";
 import type { PlanetManifest } from "./travel";
 import { env as cloudflareEnv } from "cloudflare:workers";
 import { PLANET_NAME } from "./config";
+import { doStorage } from "./do-storage";
 
 // Robust helper to get simulation variables from any available environment source
 const getSimVar = (name: string): string | undefined => {
@@ -34,6 +35,7 @@ export interface TravelPlan {
   status: "PREPARING" | "PLAN_ACCEPTED";
   traffic_controllers: string[]; // List of landing site URLs elected
   signatures: Record<string, string>; // planet_url -> signature
+  origin_lists_dest?: boolean; // Whether origin declared destination as a neighbor (set at initiation)
 }
 
 export class ConsensusEngine {
@@ -106,22 +108,26 @@ export class ConsensusEngine {
   }
 
   /**
-   * Saves plan state to KV for active consensus tracking
+   * Saves plan state to DO SQLite for active consensus tracking
    */
-  static async savePlanState(KV: KVNamespace, plan: TravelPlan) {
-    await KV.put(`consensus_plan_${plan.id}`, JSON.stringify(plan), {
-      expirationTtl: 3600,
+  static async savePlanState(
+    TRAFFIC_CONTROL: DurableObjectNamespace,
+    plan: TravelPlan,
+  ) {
+    await doStorage(TRAFFIC_CONTROL, "savePlan", {
+      planId: plan.id,
+      data: JSON.stringify(plan),
     });
   }
 
   /**
-   * Retrieves plan state from KV
+   * Retrieves plan state from DO SQLite
    */
   static async getPlanState(
-    KV: KVNamespace,
+    TRAFFIC_CONTROL: DurableObjectNamespace,
     planId: string,
   ): Promise<TravelPlan | null> {
-    const data = await KV.get(`consensus_plan_${planId}`);
-    return data ? JSON.parse(data) : null;
+    const result: any = await doStorage(TRAFFIC_CONTROL, "getPlan", { planId });
+    return result.data ? JSON.parse(result.data) : null;
   }
 }

package/template/src/lib/do-storage.ts

@@ -0,0 +1,39 @@
+/**
+ * Helper to call the TrafficControl DO's storage API.
+ */
+export async function doStorage(
+  TRAFFIC_CONTROL: DurableObjectNamespace,
+  action: string,
+  data: Record<string, any> = {},
+): Promise<any> {
+  const id = TRAFFIC_CONTROL.idFromName("global");
+  const obj = TRAFFIC_CONTROL.get(id);
+  const res = await obj.fetch("http://do/storage", {
+    method: "POST",
+    body: JSON.stringify({ action, ...data }),
+  });
+  return res.json();
+}
+
+/**
+ * Execute a SQL SELECT query through the DO and return results.
+ */
+export async function doQuery(
+  TRAFFIC_CONTROL: DurableObjectNamespace,
+  sql: string,
+  params: any[] = [],
+): Promise<any[]> {
+  const result = await doStorage(TRAFFIC_CONTROL, "query", { sql, params });
+  return result.results || [];
+}
+
+/**
+ * Execute a SQL write (INSERT/UPDATE/DELETE) through the DO.
+ */
+export async function doExec(
+  TRAFFIC_CONTROL: DurableObjectNamespace,
+  sql: string,
+  params: any[] = [],
+): Promise<void> {
+  await doStorage(TRAFFIC_CONTROL, "exec", { sql, params });
+}

package/template/src/lib/identity.ts

@@ -1,21 +1,21 @@
 import { CryptoCore } from "./crypto";
+import { doStorage } from "./do-storage";
 
 export class PlanetIdentity {
   /**
-   * Retrieves or generates the planet's Ed25519 identity keys from KV.
+   * Retrieves or generates the planet's Ed25519 identity keys from DO storage.
    */
-  static async getIdentity(KV: KVNamespace): Promise<{
+  static async getIdentity(TRAFFIC_CONTROL: DurableObjectNamespace): Promise<{
     publicKey: CryptoKey;
     privateKey: CryptoKey;
     publicKeyBase64: string;
   }> {
-    const existingPublic = await KV.get("identity_public");
-    const existingPrivate = await KV.get("identity_private");
+    const result: any = await doStorage(TRAFFIC_CONTROL, "getIdentity");
 
-    if (existingPublic && existingPrivate) {
-      const publicKey = await CryptoCore.importKey(existingPublic, "public");
-      const privateKey = await CryptoCore.importKey(existingPrivate, "private");
-      return { publicKey, privateKey, publicKeyBase64: existingPublic };
+    if (result.public && result.private) {
+      const publicKey = await CryptoCore.importKey(result.public, "public");
+      const privateKey = await CryptoCore.importKey(result.private, "private");
+      return { publicKey, privateKey, publicKeyBase64: result.public };
     }
 
     // Generate new if not found
@@ -23,8 +23,10 @@ export class PlanetIdentity {
     const publicB64 = await CryptoCore.exportKey(keyPair.publicKey);
     const privateB64 = await CryptoCore.exportKey(keyPair.privateKey);
 
-    await KV.put("identity_public", publicB64);
-    await KV.put("identity_private", privateB64);
+    await doStorage(TRAFFIC_CONTROL, "setIdentity", {
+      publicKey: publicB64,
+      privateKey: privateB64,
+    });
 
     return {
       publicKey: keyPair.publicKey,