@hazae41/bobine 0.0.17 → 0.0.19

package/README.md

@@ -2,6 +2,10 @@
 
 A blockchain in your garage
 
+```bash
+npm install -g @hazae41/bobine
+```
+
 [**🌐 Website**](https://bobine.tech/) • [**📦 NPM**](https://www.npmjs.com/package/@hazae41/bobine)
 
 ## Features

package/out/mods/helper/bin.js

@@ -50,7 +50,7 @@ self.addEventListener("message", async (event) => {
         }
         if (request.method === "ed25519_verify") {
             const [pubkeyAsBytes, signatureAsBytes, payloadAsBytes] = request.params;
-            const pubkeyAsKey = await crypto.subtle.importKey("raw", pubkeyAsBytes, "Ed25519", true, ["verify"]);
+            const pubkeyAsKey = await crypto.subtle.importKey("spki", pubkeyAsBytes, "Ed25519", true, ["verify"]);
             const verified = await crypto.subtle.verify("Ed25519", pubkeyAsKey, signatureAsBytes, payloadAsBytes);
             request.result[0] = 1;
             request.result[1] = verified ? 1 : 0;

package/out/mods/server/mod.js

@@ -51,7 +51,7 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-import { Writable } from "@hazae41/binary";
+import { Readable, Writable } from "@hazae41/binary";
 import { RpcRequest, RpcResponse } from "@hazae41/jsonrpc";
 import { Mutex } from "@hazae41/mutex";
 import { connect } from "@tursodatabase/database";
@@ -92,7 +92,7 @@ export async function serve(config) {
 
     module TEXT NOT NULL,
     
-    key TEXT NOT NULL,
+    key BLOB NOT NULL,
 
     value BLOB NOT NULL
   );`);
@@ -117,12 +117,12 @@ export async function serve(config) {
         if (match = new URLPattern("/api/create", request.url).exec(request.url)) {
             if (request.method === "POST") {
                 const form = await request.formData();
-                const wasmAsEntry = form.get("code");
-                if (wasmAsEntry == null)
+                const codeAsEntry = form.get("code");
+                if (codeAsEntry == null)
                     return Response.json(null, { status: 400 });
-                if (typeof wasmAsEntry === "string")
+                if (typeof codeAsEntry === "string")
                     return Response.json(null, { status: 400 });
-                const wasmAsBytes = await wasmAsEntry.bytes();
+                const codeAsBytes = await codeAsEntry.bytes();
                 const saltAsEntry = form.get("salt");
                 if (saltAsEntry == null)
                     return Response.json(null, { status: 400 });
@@ -142,17 +142,18 @@ export async function serve(config) {
                     return Response.json(null, { status: 402 });
                 setOfEffortsAsHex.add(effortAsHex);
                 const sparksAsBigInt = (2n ** 256n) / BigInt("0x" + new Uint8Array(await crypto.subtle.digest("SHA-256", effortAsBytes)).toHex());
-                if (sparksAsBigInt < (wasmAsBytes.length + saltAsBytes.length))
+                if (sparksAsBigInt < (codeAsBytes.length + saltAsBytes.length))
                     return Response.json(null, { status: 402 });
-                const packAsBytes = Writable.writeToBytesOrThrow(new Packed([wasmAsBytes, saltAsBytes]));
-                const digestOfWasmAsBytes = new Uint8Array(await crypto.subtle.digest("SHA-256", wasmAsBytes));
+                const saltAsValue = Readable.readFromBytesOrThrow(Packed, saltAsBytes);
+                const packAsBytes = Writable.writeToBytesOrThrow(new Packed([codeAsBytes, saltAsValue]));
+                const digestOfCodeAsBytes = new Uint8Array(await crypto.subtle.digest("SHA-256", codeAsBytes));
                 const digestOfPackAsBytes = new Uint8Array(await crypto.subtle.digest("SHA-256", packAsBytes));
-                const digestOfWasmAsHex = digestOfWasmAsBytes.toHex();
+                const digestOfCodeAsHex = digestOfCodeAsBytes.toHex();
                 const digestOfPackAsHex = digestOfPackAsBytes.toHex();
-                if (!existsSync(`${config.scripts.path}/${digestOfWasmAsHex}.wasm`))
-                    writeFileSync(`${config.scripts.path}/${digestOfWasmAsHex}.wasm`, wasmAsBytes);
+                if (!existsSync(`${config.scripts.path}/${digestOfCodeAsHex}.wasm`))
+                    writeFileSync(`${config.scripts.path}/${digestOfCodeAsHex}.wasm`, codeAsBytes);
                 if (!existsSync(`${config.scripts.path}/${digestOfPackAsHex}.wasm`))
-                    symlinkSync(`./${digestOfWasmAsHex}.wasm`, `${config.scripts.path}/${digestOfPackAsHex}.wasm`);
+                    symlinkSync(`./${digestOfCodeAsHex}.wasm`, `${config.scripts.path}/${digestOfPackAsHex}.wasm`);
                 return Response.json(digestOfPackAsHex);
             }
             return Response.json(null, { status: 405, headers: { "Allow": "POST" } });

package/out/mods/worker/bin.js

@@ -69,7 +69,7 @@ function run(module, method, params, mode, maxsparks) {
                 throw new Error("Aborted");
             },
             uuid: () => {
-                return Uint8Array.fromHex("8a8f19d1de0e4fcd9ab15cd7ed5de6dd");
+                return "17fa1cb5-c5af-4cfd-9bea-1a36590b890d";
             }
         };
         imports["sparks"] = {
@@ -225,6 +225,9 @@ function run(module, method, params, mode, maxsparks) {
             dec: (value) => {
                 return value - 1n;
             },
+            neg: (value) => {
+                return -value;
+            },
             add: (left, right) => {
                 return left + right;
             },
@@ -240,6 +243,27 @@ function run(module, method, params, mode, maxsparks) {
             pow: (left, right) => {
                 return left ** right;
             },
+            mod: (left, right) => {
+                return left % right;
+            },
+            lt: (left, right) => {
+                return left < right;
+            },
+            lte: (left, right) => {
+                return left <= right;
+            },
+            gt: (left, right) => {
+                return left > right;
+            },
+            gte: (left, right) => {
+                return left >= right;
+            },
+            eq: (left, right) => {
+                return left === right;
+            },
+            neq: (left, right) => {
+                return left !== right;
+            },
             from_base16: (text) => {
                 return BigInt("0x" + text);
             },
@@ -254,60 +278,60 @@ function run(module, method, params, mode, maxsparks) {
             }
         };
         imports["modules"] = {
-            create: (wasmAsBytes, saltAsBytes) => {
-                const packAsBytes = pack_encode([wasmAsBytes, saltAsBytes]);
-                const digestOfWasmAsBytes = sha256_digest(wasmAsBytes);
-                const digestOfPackAsBytes = sha256_digest(packAsBytes);
-                const digestOfWasmAsHex = digestOfWasmAsBytes.toHex();
-                const digestOfPackAsHex = digestOfPackAsBytes.toHex();
-                if (!existsSync(`${config.scripts.path}/${digestOfWasmAsHex}.wasm`))
-                    writeFileSync(`${config.scripts.path}/${digestOfWasmAsHex}.wasm`, wasmAsBytes);
-                if (!existsSync(`${config.scripts.path}/${digestOfPackAsHex}.wasm`))
-                    symlinkSync(`./${digestOfWasmAsHex}.wasm`, `${config.scripts.path}/${digestOfPackAsHex}.wasm`, "file");
-                return digestOfPackAsBytes;
-            },
-            call: (moduleAsBytes, methodAsBytes, paramsAsPack) => {
-                const moduleAsString = moduleAsBytes.toHex();
-                const methodAsString = new TextDecoder().decode(methodAsBytes);
-                if (exports[moduleAsString] == null)
-                    load(moduleAsString);
-                if (typeof exports[moduleAsString][methodAsString] !== "function")
-                    throw new Error("Not found");
-                return exports[moduleAsString][methodAsString](...paramsAsPack);
+            self: () => {
+                return module;
             },
-            load: (moduleAsBytes) => {
-                return readFileSync(`${config.scripts.path}/${moduleAsBytes.toHex()}.wasm`);
+            load: (module) => {
+                return readFileSync(`${config.scripts.path}/${module}.wasm`);
             },
-            self: () => {
-                return Uint8Array.fromHex(module);
+            call: (module, method, params) => {
+                if (exports[module] == null)
+                    load(module);
+                if (typeof exports[module][method] !== "function")
+                    throw new Error("Not found");
+                return [exports[module][method](...params)];
+            },
+            create: (code, salt) => {
+                const pack = pack_encode([code, salt]);
+                const digestOfCodeAsBytes = sha256_digest(code);
+                const digestOfPackAsBytes = sha256_digest(pack);
+                const digestOfCodeAsHex = digestOfCodeAsBytes.toHex();
+                const digestOfPackAsHex = digestOfPackAsBytes.toHex();
+                if (!existsSync(`${config.scripts.path}/${digestOfCodeAsHex}.wasm`))
+                    writeFileSync(`${config.scripts.path}/${digestOfCodeAsHex}.wasm`, code);
+                if (!existsSync(`${config.scripts.path}/${digestOfPackAsHex}.wasm`))
+                    symlinkSync(`./${digestOfCodeAsHex}.wasm`, `${config.scripts.path}/${digestOfPackAsHex}.wasm`, "file");
+                return digestOfPackAsHex;
             }
         };
         imports["storage"] = {
             set: (key, fresh) => {
                 const cache = caches.get(module);
                 cache.set(key, fresh);
-                const value = pack_encode(fresh);
-                writes.push([module, key, value]);
+                const keyAsBytes = pack_encode(key);
+                const valueAsBytes = pack_encode(fresh);
+                writes.push([module, keyAsBytes, valueAsBytes]);
                 return;
             },
             get: (key) => {
                 const cache = caches.get(module);
                 const stale = cache.get(key);
                 if (stale != null)
-                    return stale;
+                    return [stale];
+                const keyAsBytes = pack_encode(key);
                 const result = new Int32Array(new SharedArrayBuffer(4 + 4 + 4, { maxByteLength: ((4 + 4 + 4) + (1024 * 1024)) }));
-                helper.postMessage({ method: "storage_get", params: [module, key], result });
+                helper.postMessage({ method: "storage_get", params: [module, keyAsBytes], result });
                 if (Atomics.wait(result, 0, 0) !== "ok")
                     throw new Error("Failed to wait");
                 if (result[0] === 2)
                     throw new Error("Internal error");
                 if (result[1] === 2)
                     return null;
-                const value = new Uint8Array(result.buffer, 4 + 4 + 4, result[2]).slice();
-                const fresh = pack_decode(value);
+                const valueAsBytes = new Uint8Array(result.buffer, 4 + 4 + 4, result[2]).slice();
+                reads.push([module, keyAsBytes, valueAsBytes]);
+                const fresh = pack_decode(valueAsBytes);
                 cache.set(key, fresh);
-                reads.push([module, key, value]);
-                return fresh;
+                return [fresh];
             }
         };
         imports["symbols"] = {
@@ -346,19 +370,19 @@ function run(module, method, params, mode, maxsparks) {
                 return ed25519_sign(payload);
             }
         };
-        let meteredWasmAsBytes;
+        let meteredCodeAsBytes;
         if (!existsSync(`${config.scripts.path}/${module}.metered.wasm`)) {
-            const wasmAsBytes = readFileSync(`${config.scripts.path}/${module}.wasm`);
-            const wasmAsParsed = Readable.readFromBytesOrThrow(Wasm.Module, wasmAsBytes);
-            meter(wasmAsParsed, "sparks", "consume");
-            meteredWasmAsBytes = Writable.writeToBytesOrThrow(wasmAsParsed);
-            writeFileSync(`${config.scripts.path}/${module}.metered.wasm`, meteredWasmAsBytes);
+            const codeAsBytes = readFileSync(`${config.scripts.path}/${module}.wasm`);
+            const codeAsWasm = Readable.readFromBytesOrThrow(Wasm.Module, codeAsBytes);
+            meter(codeAsWasm, "sparks", "consume");
+            meteredCodeAsBytes = Writable.writeToBytesOrThrow(codeAsWasm);
+            writeFileSync(`${config.scripts.path}/${module}.metered.wasm`, meteredCodeAsBytes);
         }
         else {
-            meteredWasmAsBytes = readFileSync(`${config.scripts.path}/${module}.metered.wasm`);
+            meteredCodeAsBytes = readFileSync(`${config.scripts.path}/${module}.metered.wasm`);
         }
-        const meteredWasmAsModule = new WebAssembly.Module(meteredWasmAsBytes);
-        for (const descriptor of WebAssembly.Module.imports(meteredWasmAsModule)) {
+        const meteredCodeAsModule = new WebAssembly.Module(meteredCodeAsBytes);
+        for (const descriptor of WebAssembly.Module.imports(meteredCodeAsModule)) {
             if (imports[descriptor.module] != null) {
                 // NOOP
                 continue;
@@ -371,10 +395,10 @@ function run(module, method, params, mode, maxsparks) {
             imports[descriptor.module] = instance.exports;
             continue;
         }
-        const meteredWasmAsInstance = new WebAssembly.Instance(meteredWasmAsModule, imports);
-        current.instance = meteredWasmAsInstance;
-        current.module = meteredWasmAsModule;
-        exports[module] = meteredWasmAsInstance.exports;
+        const meteredCodeAsInstance = new WebAssembly.Instance(meteredCodeAsModule, imports);
+        current.instance = meteredCodeAsInstance;
+        current.module = meteredCodeAsModule;
+        exports[module] = meteredCodeAsInstance.exports;
         return current;
     };
     const { instance } = load(module);

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@hazae41/bobine",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "description": "A blockchain in your garage",
   "repository": "github:hazae41/bobine",
   "author": "hazae41",
@@ -9,8 +9,8 @@
   "scripts": {
     "examine": "deno lint ./src && deno check ./src && deno test -R ./src",
     "prepack": "rm -rf ./out && tsc && tscousin",
-    "produce": "deno run -A ./src/mod.ts serve --env=./.env.local",
-    "develop": "deno run -A ./src/mod.ts serve --env=./.env.local --dev"
+    "produce": "deno run -A --sloppy-imports ./src/mod.ts serve --env=./.env.local",
+    "develop": "deno run -A --sloppy-imports ./src/mod.ts serve --env=./.env.local --dev"
   },
   "files": [
     "./out"