@hazae41/bobine 0.0.6 → 0.0.8

package/README.md

@@ -2,6 +2,10 @@
 
 A blockchain in your garage
 
+https://bobine.tech/
+
+[**📦 NPM**](https://www.npmjs.com/package/@hazae41/bobine) • [**📦 JSR**](https://jsr.io/@hazae41/bobine)
+
 ## Features
 
 - Ultra simple
@@ -17,10 +21,41 @@ A blockchain in your garage
 
 ### Binary
 
-Run the server with Deno
+Install the binary with Deno
+
+```bash
+deno install -gf -A jsr:@hazae41/bobine
+```
+
+Generate an Ed25519 keypair by running the following code in your browser/deno/node/bun console
+
+```typescript
+const keypair = await crypto.subtle.generateKey("Ed25519", true, ["sign", "verify"])
+
+const privateKey = await crypto.subtle.exportKey("pkcs8", keypair.privateKey)
+
+const publicKey = await crypto.subtle.exportKey("raw", keypair.publicKey)
+
+console.log(`ED25519_PRIVATE_KEY_HEX=${new Uint8Array(privateKey).toHex()}`)
+
+console.log(`ED25519_PUBLIC_KEY_HEX=${new Uint8Array(publicKey).toHex()}`)
+```
+
+Create an `.env.local` file and replace your Ed25519 values
+
+```env
+DATABASE_PATH=./local/database.db
+
+SCRIPTS_PATH=./local/scripts
+
+ED25519_PRIVATE_KEY_HEX=302e020100300506032b657004220420edff8b2503b91f58bc0f0435ca17de549f89d6a7cde4c277161e031669395005
+ED25519_PUBLIC_KEY_HEX=90dcd81a473a4e59a84df6cb8f77af3d34c7fd6171ed959ca04a75f07a57b4b9
+```
+
+Run the server
 
 ```bash
-deno run --env-file=./.env.local -A npm:@hazae41/bobine
+bobine serve --env=./.env.local
 ```
 
 ### Library
@@ -71,16 +106,29 @@ Accepts a form data with the following fields
 
 ## WebAssembly API
 
-### <module>
+The WebAssembly VM extensively uses reference types for its API and for module-to-module communication
+
+### AssemblyScript
+
+You can use [stdbob](https://github.com/hazae41/stdbob) to easily import AssemblyScript declarations for all internal modules
 
-You can use any module method by using the module address as hex
+Or you can declare internal modules manually with the module name and method name
+
+```tsx
+@external("bigints", "add")
+declare function add(x: externref, y: externref): externref
+```
+
+And you can declare external modules by using the module address as hex
 
 ```tsx
 @external("5feeee846376f6436990aa2757bc67fbc4498bcc9993b647788e273ad6fde474", "add")
-declare function add(x: i32, y: i32): i32
+declare function add(x: externref, y: externref): externref
 ```
 
-### blobs
+### All internal modules
+
+#### blobs
 
 You can pass bytes between modules by storing them in the blob storage and loading them via reference
 
@@ -94,7 +142,7 @@ You can pass bytes between modules by storing them in the blob storage and loadi
 
 - `blob.to_hex/from_hex/to_base64/from_base64(blob: blobref): blobref` = convert blobs to/from hex/base64 without loading them into memory
 
-### bigints
+#### bigints
 
 You can work with infinite-precision bigints
 
@@ -120,7 +168,7 @@ You can work with infinite-precision bigints
 
 - `bigints.from_base10(base16: blobref): bigintref` = convert base10 utf8 bytes to bigint
 
-### packs
+#### packs
 
 You can pack various arguments (numbers, refs) into a pack which can be passed between modules and/or encoded/decoded into bytes
 
@@ -175,7 +223,9 @@ function writePack(pack: packref) {
 
 - `packs.get<T>(pack: packref, index: i32): T` = get the value of a pack at `index` (throws if not found)
 
-### env
+- `packs.length(pack: packref): i32` = get the length of a pack
+
+#### env
 
 Get infos about the executing environment
 
@@ -183,7 +233,7 @@ Get infos about the executing environment
 
 - `env.uuid(): blobref` = get the unique uuid of this environment (similar to a chain id)
 
-### modules
+#### modules
 
 Modules are identified by their address as a blob of bytes (pure sha256-output 32-length bytes without any encoding)
 
@@ -195,7 +245,7 @@ Modules are identified by their address as a blob of bytes (pure sha256-output 3
 
 - `modules.self(): blobref` = get your module address as blob
 
-### storage
+#### storage
 
 You can use a private storage (it works like storage and events at the same time)
 
@@ -203,13 +253,13 @@ You can use a private storage (it works like storage and events at the same time
 
 - `storage.get(key: blobref): blobref` = get the latest value from storage at key
 
-### sha256
+#### sha256
 
 Use the SHA-256 hashing algorithm
 
 - `sha256.digest(payload: blobref): blobref` = hash the payload and returns the digest
 
-### ed25519
+#### ed25519
 
 Use the Ed25519 signing algorithm
 
@@ -217,11 +267,11 @@ Use the Ed25519 signing algorithm
 
 - `ed25519.sign(payload: blobref): blobref` = (experimental) sign payload using the miner's private key
 
-### symbols (experimental)
+#### symbols (experimental)
 
 - `symbols.create(): symbolref` = create a unique reference that can be passed around
 
-### refs (experimental)
+#### refs (experimental)
 
 - `refs.numerize(ref: symbolref/blobref/packref): i32` = translate any reference into a unique private pointer that can be stored into data structures
 
@@ -245,4 +295,4 @@ export function verify(session: symbolref) {
 }
 ```
 
-You should never accept a pointer instead of a real reference because they can be easily guessed by an attacking module
+You should never accept a pointer instead of a real reference because they can be easily guessed by an attacking module

package/out/mod.d.ts

@@ -1 +1,3 @@
+#!/usr/bin/env deno
 export * from "./mods/mod.ts";
+export declare function main(args: string[]): Promise<void>;

package/out/mod.js

@@ -1 +1,40 @@
+#!/usr/bin/env deno
 export * from "./mods/mod.js";
+import process from "node:process";
+import * as server from "./mods/server/bin.js";
+export async function main(args) {
+    const subargs = new Array();
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.startsWith("--")) {
+            subargs.push(arg);
+            continue;
+        }
+        if (arg === "serve") {
+            subargs.push(...args.slice(i + 1));
+            await server.main(subargs);
+            return;
+        }
+        if (arg === "create") {
+            console.log("Create command is not implemented yet.");
+            return;
+        }
+        if (arg === "execute") {
+            console.log("Execute command is not implemented yet.");
+            return;
+        }
+        if (arg === "simulate") {
+            console.log("Simulate command is not implemented yet.");
+            return;
+        }
+        break;
+    }
+    console.log("- serve [--env=<env file as path>] [--port=<port>] [--dev]");
+    console.log("- create <wasm file as path> [salt as hex]");
+    console.log("- execute <module as hex> <function name> [args as pack as hex]");
+    console.log("- simulate <module as hex> <function name> [args as pack as hex]");
+    return;
+}
+if (import.meta.main) {
+    await main(process.argv.slice(2));
+}

package/out/mods/server/bin.d.ts

@@ -1 +1 @@
-export {};
+export declare function main(args: string[]): Promise<void>;

package/out/mods/server/bin.js

@@ -1,34 +1,69 @@
 import { readFileSync } from "node:fs";
 import process from "node:process";
 import { serveWithEnv } from "./mod.js";
-const { PORT = process.env.PORT || "8080", CERT = process.env.CERT, KEY = process.env.KEY, } = process.env;
-const port = Number(PORT);
-const cert = CERT != null ? readFileSync(CERT, "utf8") : undefined;
-const key = KEY != null ? readFileSync(KEY, "utf8") : undefined;
-const server = await serveWithEnv();
-const route = async (request) => {
-    if (request.method === "OPTIONS")
-        return new Response(null, { status: 204 });
-    if (request.headers.get("Upgrade") === "websocket") {
-        const { socket, response } = Deno.upgradeWebSocket(request);
-        await server.onWebSocketRequest(request, socket);
-        return response;
+export async function main(args) {
+    const config = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.startsWith("--env=")) {
+            process.loadEnvFile(arg.slice("--env=".length));
+            continue;
+        }
+        if (arg.startsWith("--port=")) {
+            config.port = Number(arg.slice("--port=".length));
+            continue;
+        }
+        if (arg.startsWith("--cert=")) {
+            config.cert = readFileSync(arg.slice("--cert=".length), "utf8");
+            continue;
+        }
+        if (arg.startsWith("--key=")) {
+            config.key = readFileSync(arg.slice("--key=".length), "utf8");
+            continue;
+        }
+        if (arg === "--dev=true") {
+            process.env.NODE_ENV = "development";
+            continue;
+        }
+        if (arg === "--dev=false") {
+            process.env.NODE_ENV = "production";
+            continue;
+        }
+        if (arg === "--dev") {
+            process.env.NODE_ENV = "development";
+            continue;
+        }
+        throw new Error(`Unknown argument: ${arg}`);
     }
-    return await server.onHttpRequest(request);
-};
-const onHttpRequest = async (request) => {
-    try {
-        const response = await route(request);
-        if (response.status === 101)
+    const { port = Number(process.env.PORT) || 8080, cert = process.env.CERT != null ? readFileSync(process.env.CERT, "utf8") : undefined, key = process.env.KEY != null ? readFileSync(process.env.KEY, "utf8") : undefined, } = config;
+    const server = await serveWithEnv();
+    const route = async (request) => {
+        if (request.method === "OPTIONS")
+            return new Response(null, { status: 204 });
+        if (request.headers.get("Upgrade") === "websocket") {
+            const { socket, response } = Deno.upgradeWebSocket(request);
+            await server.onWebSocketRequest(request, socket);
             return response;
-        response.headers.set("Access-Control-Allow-Origin", "*");
-        response.headers.set("Access-Control-Allow-Methods", "*");
-        response.headers.set("Access-Control-Allow-Headers", "*");
-        return response;
-    }
-    catch (cause) {
-        console.error(cause);
-        return new Response("Error", { status: 500 });
-    }
-};
-Deno.serve({ hostname: "0.0.0.0", port, cert, key }, onHttpRequest);
+        }
+        return await server.onHttpRequest(request);
+    };
+    const onHttpRequest = async (request) => {
+        try {
+            const response = await route(request);
+            if (response.status === 101)
+                return response;
+            response.headers.set("Access-Control-Allow-Origin", "*");
+            response.headers.set("Access-Control-Allow-Methods", "*");
+            response.headers.set("Access-Control-Allow-Headers", "*");
+            return response;
+        }
+        catch (cause) {
+            console.error(cause);
+            return new Response("Error", { status: 500 });
+        }
+    };
+    Deno.serve({ hostname: "0.0.0.0", port, cert, key }, onHttpRequest);
+}
+if (import.meta.main) {
+    await main(process.argv.slice(2));
+}

package/out/mods/server/mod.d.ts

@@ -1,4 +1,4 @@
-import { Config } from "../config/mod.ts";
+import type { Config } from "../config/mod.ts";
 export declare function serveWithEnv(prefix?: string): Promise<{
     onHttpRequest(request: Request): Promise<Response>;
     onWebSocketRequest(request: Request, socket: WebSocket): Promise<void>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@hazae41/bobine",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "A blockchain in your garage",
   "repository": "github:hazae41/bobine",
   "author": "hazae41",
@@ -11,7 +11,8 @@
     "version": "deno -RW ./x.vsync.ts && git add deno.json",
     "prepare": "deno -RW ./x.dsync.ts && deno install",
     "prepack": "rm -rf ./out && tsc && tscousin",
-    "develop": "NODE_ENV=development deno --env-file=./.env.local -A ./src/mods/server/bin.ts"
+    "produce": "deno run -A ./src/bin.ts serve --env=./.env.local",
+    "develop": "deno run -A ./src/bin.ts serve --env=./.env.local --dev"
   },
   "files": [
     "./out"
@@ -20,18 +21,6 @@
     ".": {
       "types": "./out/mod.d.ts",
       "import": "./out/mod.js"
-    },
-    "./server": {
-      "types": "./out/mods/server/bin.d.ts",
-      "import": "./out/mods/server/bin.js"
-    },
-    "./worker": {
-      "types": "./out/mods/worker/bin.d.ts",
-      "import": "./out/mods/worker/bin.js"
-    },
-    "./helper": {
-      "types": "./out/mods/helper/bin.d.ts",
-      "import": "./out/mods/helper/bin.js"
     }
   },
   "dependencies": {
@@ -45,7 +34,7 @@
   "devDependencies": {
     "@hazae41/phobos": "^2.0.16",
     "@hazae41/tscousin": "^1.0.28",
-    "@types/node": "^24.10.1",
+    "@types/node": "^25.0.2",
     "typescript": "^5.9.3"
   },
   "keywords": [
@@ -57,6 +46,6 @@
     "unit-tested"
   ],
   "bin": {
-    "bobine": "./out/mods/server/bin.js"
+    "bobine": "./out/mod.js"
   }
 }