@hazae41/bobine 0.0.9 → 0.0.11

package/README.md

@@ -21,8 +21,6 @@ https://bobine.tech/
 
 ### Running the server
 
-#### Running the server via binary
-
 Install the binary with Deno
 
 ```bash
@@ -60,25 +58,11 @@ Run the server
 bobine serve --env=./.env.local
 ```
 
-#### Running the server via library
-
-Install `@hazae41/bobine` and use the `serve()` function
-
-### Creating a module
-
-#### Creating a module via binary
-
-Install the binary with Deno
-
-```bash
-deno install -gf -A jsr:@hazae41/bobine
-```
+Or you can install `@hazae41/bobine` and use the `serve()` function
 
-Deploy your .wasm file
+### Making your own module
 
-```bash
-bobine create ./module.wasm --server=http://localhost:8080
-```
+You can clone my [AssemblyScript starter](https://github.com/hazae41/create-bobine-assemblyscript-module) to get started with AssemblyScript
 
 ### Using the HTTP API
 

package/out/libs/metering/mod.js

@@ -1,17 +1,28 @@
 import * as Wasm from "@hazae41/wasm";
 export function meter(module, from, name) {
-    const wtype = module.body.sections.find(section => section.kind === Wasm.TypeSection.kind);
-    const wimport = module.body.sections.find(section => section.kind === Wasm.ImportSection.kind);
-    const wexport = module.body.sections.find(section => section.kind === Wasm.ExportSection.kind);
-    const wcode = module.body.sections.find(section => section.kind === Wasm.CodeSection.kind);
-    if (wtype == null)
-        throw new Error(`No type section`);
-    if (wimport == null)
-        throw new Error(`No import section`);
-    if (wexport == null)
-        throw new Error(`No export section`);
-    if (wcode == null)
-        throw new Error(`No code section`);
+    let wtype = module.body.sections.find(section => section.kind === Wasm.TypeSection.kind);
+    if (wtype == null) {
+        wtype = new Wasm.TypeSection([]);
+        module.body.sections.unshift(wtype);
+    }
+    let wimport = module.body.sections.find(section => section.kind === Wasm.ImportSection.kind);
+    if (wimport == null) {
+        wimport = new Wasm.ImportSection([]);
+        const before = module.body.sections.findLastIndex(section => section.kind < Wasm.ImportSection.kind);
+        module.body.sections.splice(before + 1, 0, wimport);
+    }
+    let wexport = module.body.sections.find(section => section.kind === Wasm.ExportSection.kind);
+    if (wexport == null) {
+        wexport = new Wasm.ExportSection([]);
+        const before = module.body.sections.findLastIndex(section => section.kind < Wasm.ExportSection.kind);
+        module.body.sections.splice(before + 1, 0, wexport);
+    }
+    let wcode = module.body.sections.find(section => section.kind === Wasm.CodeSection.kind);
+    if (wcode == null) {
+        wcode = new Wasm.CodeSection([]);
+        const before = module.body.sections.findLastIndex(section => section.kind < Wasm.CodeSection.kind);
+        module.body.sections.splice(before + 1, 0, wcode);
+    }
     const wstart = module.body.sections.find(section => section.kind === Wasm.StartSection.kind);
     wtype.descriptors.push({ prefix: Wasm.TypeSection.FuncType.kind, subtypes: [], body: new Wasm.TypeSection.FuncType([0x7f], []) });
     wimport.descriptors.unshift({ from: new TextEncoder().encode(from), name: new TextEncoder().encode(name), body: new Wasm.ImportSection.FunctionImport(wtype.descriptors.length - 1) });

package/out/libs/packs/mod.d.ts

@@ -6,6 +6,8 @@ export declare class Pack {
     writeOrThrow(cursor: Cursor): void;
 }
 export declare namespace Pack {
-    type Value = null | number | bigint | Uint8Array | Pack;
-    function readOrThrow(cursor: Cursor): Pack;
+    type Value = null | number | Uint8Array | string | bigint | Array<Value>;
+    function readOrThrow(cursor: Cursor): Array<Value>;
+    function sizeOrThrow(values: Array<Value>): number;
+    function writeOrThrow(values: Array<Value>, cursor: Cursor): void;
 }

package/out/libs/packs/mod.js

@@ -1,32 +1,88 @@
-/// <reference types="../bytes/lib.d.ts"/>
+// deno-lint-ignore-file no-namespace
 export class Pack {
     values;
     constructor(values) {
         this.values = values;
     }
     sizeOrThrow() {
+        return Pack.sizeOrThrow(this.values);
+    }
+    writeOrThrow(cursor) {
+        Pack.writeOrThrow(this.values, cursor);
+    }
+}
+(function (Pack) {
+    function readOrThrow(cursor) {
+        const values = [];
+        while (true) {
+            const type = cursor.readUint8OrThrow();
+            if (type === 0)
+                break;
+            if (type === 1) {
+                values.push(null);
+                continue;
+            }
+            if (type === 2) {
+                values.push(Pack.readOrThrow(cursor));
+                continue;
+            }
+            if (type === 3) {
+                values.push(cursor.readFloat64OrThrow(true));
+                continue;
+            }
+            if (type === 4) {
+                const size = cursor.readUint32OrThrow(true);
+                values.push(cursor.readOrThrow(size));
+                continue;
+            }
+            if (type === 5) {
+                const size = cursor.readUint32OrThrow(true);
+                const data = cursor.readOrThrow(size);
+                values.push(new TextDecoder().decode(data));
+                continue;
+            }
+            if (type === 6) {
+                const negative = cursor.readUint8OrThrow();
+                const size = cursor.readUint32OrThrow(true);
+                const data = cursor.readOrThrow(size);
+                const absolute = BigInt("0x" + data.toHex());
+                values.push(negative ? -absolute : absolute);
+                continue;
+            }
+            throw new Error("Unknown pack type");
+        }
+        return values;
+    }
+    Pack.readOrThrow = readOrThrow;
+    function sizeOrThrow(values) {
         let size = 0;
-        for (const value of this.values) {
+        for (const value of values) {
             if (value == null) {
                 size += 1;
                 continue;
             }
-            if (typeof value === "number") {
-                size += 1 + 4;
+            if (Array.isArray(value)) {
+                size += 1 + sizeOrThrow(value);
                 continue;
             }
-            if (typeof value === "bigint") {
-                const text = value.toString(16);
-                const data = Uint8Array.fromHex(text.length % 2 === 1 ? "0" + text : text);
-                size += 1 + 4 + data.length;
+            if (typeof value === "number") {
+                size += 1 + 4;
                 continue;
             }
             if (value instanceof Uint8Array) {
                 size += 1 + 4 + value.length;
                 continue;
             }
-            if (value instanceof Pack) {
-                size += 1 + value.sizeOrThrow();
+            if (typeof value === "string") {
+                const data = new TextEncoder().encode(value);
+                size += 1 + 4 + data.length;
+                continue;
+            }
+            if (typeof value === "bigint") {
+                const absolute = value < 0n ? -value : value;
+                const text = absolute.toString(16);
+                const data = Uint8Array.fromHex(text.length % 2 === 1 ? "0" + text : text);
+                size += 1 + 1 + 4 + data.length;
                 continue;
             }
             throw new Error("Unknown pack value");
@@ -34,23 +90,21 @@ export class Pack {
         size += 1;
         return size;
     }
-    writeOrThrow(cursor) {
-        for (const value of this.values) {
+    Pack.sizeOrThrow = sizeOrThrow;
+    function writeOrThrow(values, cursor) {
+        for (const value of values) {
             if (value == null) {
                 cursor.writeUint8OrThrow(1);
                 continue;
             }
-            if (typeof value === "number") {
+            if (Array.isArray(value)) {
                 cursor.writeUint8OrThrow(2);
-                cursor.writeFloat64OrThrow(value, true);
+                writeOrThrow(value, cursor);
                 continue;
             }
-            if (typeof value === "bigint") {
+            if (typeof value === "number") {
                 cursor.writeUint8OrThrow(3);
-                const text = value.toString(16);
-                const data = Uint8Array.fromHex(text.length % 2 === 1 ? "0" + text : text);
-                cursor.writeUint32OrThrow(data.length, true);
-                cursor.writeOrThrow(data);
+                cursor.writeFloat64OrThrow(value, true);
                 continue;
             }
             if (value instanceof Uint8Array) {
@@ -59,9 +113,21 @@ export class Pack {
                 cursor.writeOrThrow(value);
                 continue;
             }
-            if (value instanceof Pack) {
+            if (typeof value === "string") {
                 cursor.writeUint8OrThrow(5);
-                value.writeOrThrow(cursor);
+                const data = new TextEncoder().encode(value);
+                cursor.writeUint32OrThrow(data.length, true);
+                cursor.writeOrThrow(data);
+                continue;
+            }
+            if (typeof value === "bigint") {
+                cursor.writeUint8OrThrow(6);
+                const [negative, absolute] = value < 0n ? [1, -value] : [0, value];
+                const text = absolute.toString(16);
+                const data = Uint8Array.fromHex(text.length % 2 === 1 ? "0" + text : text);
+                cursor.writeUint8OrThrow(negative);
+                cursor.writeUint32OrThrow(data.length, true);
+                cursor.writeOrThrow(data);
                 continue;
             }
             throw new Error("Unknown pack value");
@@ -69,40 +135,5 @@ export class Pack {
         cursor.writeUint8OrThrow(0);
         return;
     }
-}
-(function (Pack) {
-    function readOrThrow(cursor) {
-        const values = [];
-        while (true) {
-            const type = cursor.readUint8OrThrow();
-            if (type === 0)
-                break;
-            if (type === 1) {
-                values.push(null);
-                continue;
-            }
-            if (type === 2) {
-                values.push(cursor.readFloat64OrThrow(true));
-                continue;
-            }
-            if (type === 3) {
-                const size = cursor.readUint32OrThrow(true);
-                const data = cursor.readOrThrow(size);
-                values.push(BigInt("0x" + data.toHex()));
-                continue;
-            }
-            if (type === 4) {
-                const size = cursor.readUint32OrThrow(true);
-                values.push(cursor.readOrThrow(size));
-                continue;
-            }
-            if (type === 5) {
-                values.push(Pack.readOrThrow(cursor));
-                continue;
-            }
-            throw new Error("Unknown pack type");
-        }
-        return new Pack(values);
-    }
-    Pack.readOrThrow = readOrThrow;
+    Pack.writeOrThrow = writeOrThrow;
 })(Pack || (Pack = {}));

package/out/mods/worker/bin.js

@@ -4,7 +4,6 @@ import { RpcErr, RpcError, RpcMethodNotFoundError, RpcOk } from "@hazae41/jsonrp
 import * as Wasm from "@hazae41/wasm";
 import { Buffer } from "node:buffer";
 import { existsSync, readFileSync, symlinkSync, writeFileSync } from "node:fs";
-import { log } from "../../libs/debug/mod.js";
 import { meter } from "../../libs/metering/mod.js";
 import { Pack } from "../../libs/packs/mod.js";
 const config = await fetch(self.name).then(res => res.json());
@@ -13,9 +12,11 @@ function run(module, method, params, mode, maxsparks) {
     let sparks = 0n;
     const exports = {};
     const caches = new Map();
+    const logs = new Array();
+    const reads = new Array();
     const writes = new Array();
     const pack_encode = (pack) => {
-        return Writable.writeToBytesOrThrow(pack);
+        return Writable.writeToBytesOrThrow(new Pack(pack));
     };
     const pack_decode = (bytes) => {
         return Readable.readFromBytesOrThrow(Pack, bytes);
@@ -48,7 +49,7 @@ function run(module, method, params, mode, maxsparks) {
     };
     const ed25519_sign = (subpayload) => {
         sparks_consume(BigInt(subpayload.length) * 256n);
-        const payload = pack_encode(new Pack([Uint8Array.fromHex(module), subpayload]));
+        const payload = pack_encode([Uint8Array.fromHex(module), subpayload]);
         const result = new Int32Array(new SharedArrayBuffer(4 + 64));
         helper.postMessage({ method: "ed25519_sign", params: [payload], result });
         if (Atomics.wait(result, 0, 0) !== "ok")
@@ -79,8 +80,8 @@ function run(module, method, params, mode, maxsparks) {
             }
         };
         imports["console"] = {
-            log: (blob) => {
-                log?.(new TextDecoder().decode(blob));
+            log: (text) => {
+                logs.push(text);
             }
         };
         imports["blobs"] = {
@@ -89,14 +90,14 @@ function run(module, method, params, mode, maxsparks) {
                 const view = new Uint8Array(memory.buffer, offset >>> 0, length >>> 0);
                 return view.slice();
             },
-            size: (blob) => {
-                return blob.length;
-            },
             load: (blob, offset) => {
                 const { memory } = current.instance.exports;
                 const view = new Uint8Array(memory.buffer, offset >>> 0, blob.length);
                 view.set(blob);
             },
+            length: (blob) => {
+                return blob.length;
+            },
             concat: (left, right) => {
                 const concat = new Uint8Array(left.length + right.length);
                 concat.set(left, 0);
@@ -106,31 +107,69 @@ function run(module, method, params, mode, maxsparks) {
             equals: (left, right) => {
                 return !Buffer.compare(left, right);
             },
-            from_base16: (text) => {
-                return Uint8Array.fromHex(new TextDecoder().decode(text));
+            includes: (haystack, needle) => {
+                return haystack.toHex().includes(needle.toHex());
             },
-            from_base64: (text) => {
-                return Uint8Array.fromBase64(new TextDecoder().decode(text));
+            slice: (blob, start, end) => {
+                return blob.slice(start >>> 0, end >>> 0);
+            },
+            from_base16: (text) => {
+                return Uint8Array.fromHex(text);
             },
             to_base16: (bytes) => {
-                return new TextEncoder().encode(bytes.toHex());
+                return bytes.toHex();
+            },
+            from_base64: (text) => {
+                return Uint8Array.fromBase64(text);
             },
             to_base64: (bytes) => {
-                return new TextEncoder().encode(bytes.toBase64());
+                return bytes.toBase64();
+            },
+        };
+        imports["texts"] = {
+            length: (text) => {
+                return new TextEncoder().encode(text).length;
+            },
+            concat: (left, right) => {
+                return left + right;
+            },
+            equals: (left, right) => {
+                return left === right;
+            },
+            includes: (haystack, needle) => {
+                return haystack.includes(needle);
+            },
+            slice: (text, start, end) => {
+                return text.slice(start >>> 0, end >>> 0);
+            },
+            from_utf8: (bytes) => {
+                return new TextDecoder().decode(bytes);
+            },
+            to_utf8: (text) => {
+                return new TextEncoder().encode(text);
+            },
+            to_uppercase: (text) => {
+                return text.toUpperCase();
+            },
+            to_lowercase: (text) => {
+                return text.toLowerCase();
+            },
+            trim: (text) => {
+                return text.trim();
             }
         };
         imports["packs"] = {
             create: (...values) => {
-                return new Pack(values);
+                return values;
             },
             concat: (left, right) => {
-                return new Pack([...left.values, ...right.values]);
+                return [...left, ...right];
             },
             length: (pack) => {
-                return pack.values.length;
+                return pack.length;
             },
             get(pack, index) {
-                const value = pack.values[index >>> 0];
+                const value = pack[index >>> 0];
                 if (value === undefined)
                     throw new Error("Not found");
                 return value;
@@ -143,6 +182,9 @@ function run(module, method, params, mode, maxsparks) {
             }
         };
         imports["bigints"] = {
+            identity: (value) => {
+                return value;
+            },
             zero: () => {
                 return 0n;
             },
@@ -206,21 +248,21 @@ function run(module, method, params, mode, maxsparks) {
                 return BigInt("0x" + bytes.toHex());
             },
             from_base16: (text) => {
-                return BigInt("0x" + new TextDecoder().decode(text));
+                return BigInt("0x" + text);
             },
             to_base16: (bigint) => {
-                return new TextEncoder().encode(bigint.toString(16));
+                return bigint.toString(16);
             },
             from_base10: (text) => {
-                return BigInt(new TextDecoder().decode(text));
+                return BigInt(text);
             },
             to_base10: (bigint) => {
-                return new TextEncoder().encode(bigint.toString());
+                return bigint.toString();
             }
         };
         imports["modules"] = {
             create: (wasmAsBytes, saltAsBytes) => {
-                const packAsBytes = pack_encode(new Pack([wasmAsBytes, saltAsBytes]));
+                const packAsBytes = pack_encode([wasmAsBytes, saltAsBytes]);
                 const digestOfWasmAsBytes = sha256_digest(wasmAsBytes);
                 const digestOfPackAsBytes = sha256_digest(packAsBytes);
                 const digestOfWasmAsHex = digestOfWasmAsBytes.toHex();
@@ -269,6 +311,7 @@ function run(module, method, params, mode, maxsparks) {
                     return null;
                 const fresh = new Uint8Array(result.buffer, 4 + 4 + 4, result[2]).slice();
                 cache.set(key, fresh);
+                reads.push([module, key, fresh]);
                 return fresh;
             }
         };
@@ -342,37 +385,33 @@ function run(module, method, params, mode, maxsparks) {
     const { instance } = load(module);
     if (typeof instance.exports[method] !== "function")
         throw new Error("Not found");
-    const result = pack_encode(new Pack([instance.exports[method](...pack_decode(params).values)]));
-    return { result, writes, sparks };
+    const returned = [instance.exports[method](...pack_decode(params))];
+    if (mode !== 2)
+        return pack_encode([logs, reads, writes, returned, sparks]);
+    if (writes.length) {
+        const result = new Int32Array(new SharedArrayBuffer(4 + 4));
+        helper.postMessage({ method: "storage_set", params: [module, method, params, writes], result });
+        if (Atomics.wait(result, 0, 0) !== "ok")
+            throw new Error("Failed to wait");
+        if (result[0] === 2)
+            throw new Error("Internal error");
+        // NOOP
+    }
+    return pack_encode([logs, reads, writes, returned, sparks]);
 }
 self.addEventListener("message", (event) => {
     try {
         const request = event.data;
         if (request.method === "execute") {
             const [module, method, params, maxsparks] = request.params;
-            const start = performance.now();
-            const { result, writes, sparks } = run(module, method, params, 1, maxsparks);
-            const until = performance.now();
-            log?.(`Evaluated ${(until - start).toFixed(2)}ms with ${sparks} sparks`);
-            if (writes.length) {
-                const result = new Int32Array(new SharedArrayBuffer(4 + 4));
-                helper.postMessage({ method: "storage_set", params: [module, method, params, writes], result });
-                if (Atomics.wait(result, 0, 0) !== "ok")
-                    throw new Error("Failed to wait");
-                if (result[0] === 2)
-                    throw new Error("Internal error");
-                log?.(`Wrote ${writes.length} events to storage`);
-            }
-            self.postMessage(new RpcOk(request.id, result));
+            const proof = run(module, method, params, 1, maxsparks);
+            self.postMessage(new RpcOk(request.id, proof));
             return;
         }
         if (request.method === "simulate") {
             const [module, method, params, maxsparks] = request.params;
-            const start = performance.now();
-            const { result, sparks } = run(module, method, params, 2, maxsparks);
-            const until = performance.now();
-            log?.(`Evaluated ${(until - start).toFixed(2)}ms with ${sparks} sparks`);
-            self.postMessage(new RpcOk(request.id, result));
+            const proof = run(module, method, params, 2, maxsparks);
+            self.postMessage(new RpcOk(request.id, proof));
             return;
         }
         if (request.method === "verify") {

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@hazae41/bobine",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "A blockchain in your garage",
   "repository": "github:hazae41/bobine",
   "author": "hazae41",
@@ -11,8 +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",
-    "produce": "deno run -A ./src/bin.ts serve --env=./.env.local",
-    "develop": "deno run -A ./src/bin.ts serve --env=./.env.local --dev"
+    "produce": "deno run -A ./src/mod.ts serve --env=./.env.local",
+    "develop": "deno run -A ./src/mod.ts serve --env=./.env.local --dev"
   },
   "files": [
     "./out"

package/out/libs/debug/mod.d.ts

@@ -1 +0,0 @@
-export declare const log: (message: string) => void;

package/out/libs/debug/mod.js

@@ -1,4 +0,0 @@
-import process from "node:process";
-export const log = process.env.NODE_ENV === "development"
-    ? (message) => console.debug(message)
-    : null;