@hazae41/bobine 0.0.18 → 0.0.20

package/README.md

@@ -3,7 +3,7 @@
 A blockchain in your garage
 
 ```bash
-npm install -g @hazae41/bobine
+deno install -gf -A npm:@hazae41/bobine
 ```
 
 [**🌐 Website**](https://bobine.tech/) • [**📦 NPM**](https://www.npmjs.com/package/@hazae41/bobine)
@@ -23,6 +23,12 @@ npm install -g @hazae41/bobine
 
 ### Running the server
 
+Install Deno
+
+```bash
+npm install -g deno
+```
+
 Install the binary with Deno
 
 ```bash

package/out/libs/metering/mod.js

@@ -1,57 +1,157 @@
+// deno-lint-ignore-file prefer-const
 import * as Wasm from "@hazae41/wasm";
 export function meter(module, from, name) {
     let wtype = module.body.sections.find(section => section.kind === Wasm.TypeSection.kind);
+    let wimport = module.body.sections.find(section => section.kind === Wasm.ImportSection.kind);
+    let wexport = module.body.sections.find(section => section.kind === Wasm.ExportSection.kind);
+    let wcode = module.body.sections.find(section => section.kind === Wasm.CodeSection.kind);
+    let welem = module.body.sections.find(section => section.kind === Wasm.ElementSection.kind);
+    let wstart = module.body.sections.find(section => section.kind === Wasm.StartSection.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) });
     if (wstart != null)
         wstart.funcidx++;
-    for (const body of wcode.bodies) {
-        const instructions = new Array();
-        const subinstructions = new Array();
-        for (const instruction of body.instructions) {
-            if ([0x10, 0x12, 0xd2].includes(instruction.opcode))
-                instruction.params[0].value++;
-            if ([0x03, 0x04, 0x05, 0x0B, 0x0c, 0x0D, 0x0E, 0x0F, 0xd5, 0xd6].includes(instruction.opcode)) {
-                subinstructions.push(instruction);
-                instructions.push(new Wasm.Instruction(0x41, [new Wasm.LEB128.I32(subinstructions.length)]));
-                instructions.push(new Wasm.Instruction(0x10, [new Wasm.LEB128.U32(0)]));
-                instructions.push(...subinstructions);
-                subinstructions.length = 0;
+    if (welem != null) {
+        for (const segment of welem.segments) {
+            switch (segment.flag) {
+                case 0: {
+                    for (let i = 0; i < segment.funcidxs.length; i++) {
+                        segment.funcidxs[i]++;
+                        continue;
+                    }
+                    for (const instruction of segment.instructions) {
+                        if (![0xd2].includes(instruction.opcode))
+                            continue;
+                        instruction.params[0].value++;
+                        continue;
+                    }
+                    break;
+                }
+                case 1: {
+                    for (const element of segment.elements) {
+                        for (const instruction of element) {
+                            if (![0xd2].includes(instruction.opcode))
+                                continue;
+                            instruction.params[0].value++;
+                            continue;
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 2: {
+                    for (const instruction of segment.instructions) {
+                        if (![0xd2].includes(instruction.opcode))
+                            continue;
+                        instruction.params[0].value++;
+                        continue;
+                    }
+                    for (const element of segment.elements) {
+                        for (const instruction of element) {
+                            if (![0xd2].includes(instruction.opcode))
+                                continue;
+                            instruction.params[0].value++;
+                            continue;
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 3: {
+                    for (const element of segment.elements) {
+                        for (const instruction of element) {
+                            if (![0xd2].includes(instruction.opcode))
+                                continue;
+                            instruction.params[0].value++;
+                            continue;
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 4: {
+                    for (let i = 0; i < segment.funcidxs.length; i++) {
+                        segment.funcidxs[i]++;
+                        continue;
+                    }
+                    for (const instruction of segment.instructions) {
+                        if (![0xd2].includes(instruction.opcode))
+                            continue;
+                        instruction.params[0].value++;
+                        continue;
+                    }
+                    break;
+                }
+                case 5: {
+                    for (let i = 0; i < segment.funcidxs.length; i++) {
+                        segment.funcidxs[i]++;
+                        continue;
+                    }
+                    break;
+                }
+                case 6: {
+                    for (let i = 0; i < segment.funcidxs.length; i++) {
+                        segment.funcidxs[i]++;
+                        continue;
+                    }
+                    for (const instruction of segment.instructions) {
+                        if (![0xd2].includes(instruction.opcode))
+                            continue;
+                        instruction.params[0].value++;
+                        continue;
+                    }
+                    break;
+                }
+                case 7: {
+                    for (let i = 0; i < segment.funcidxs.length; i++) {
+                        segment.funcidxs[i]++;
+                        continue;
+                    }
+                    break;
+                }
             }
-            else {
-                subinstructions.push(instruction);
+            continue;
+        }
+    }
+    if (wcode != null) {
+        for (const body of wcode.bodies) {
+            const instructions = new Array();
+            const subinstructions = new Array();
+            for (const instruction of body.instructions) {
+                if ([0x10, 0x12, 0xd2].includes(instruction.opcode))
+                    instruction.params[0].value++;
+                if ([0x03, 0x04, 0x05, 0x0B, 0x0c, 0x0D, 0x0E, 0x0F, 0xd5, 0xd6].includes(instruction.opcode)) {
+                    subinstructions.push(instruction);
+                    instructions.push(new Wasm.Instruction(0x41, [new Wasm.LEB128.I32(subinstructions.length)]));
+                    instructions.push(new Wasm.Instruction(0x10, [new Wasm.LEB128.U32(0)]));
+                    instructions.push(...subinstructions);
+                    subinstructions.length = 0;
+                }
+                else {
+                    subinstructions.push(instruction);
+                }
+                continue;
             }
+            instructions.push(...subinstructions);
+            body.instructions = instructions;
+            continue;
         }
-        instructions.push(...subinstructions);
-        body.instructions = instructions;
-        continue;
     }
-    for (const descriptor of wexport.descriptors) {
-        if (descriptor.kind !== 0x00)
+    if (wexport != null) {
+        for (const descriptor of wexport.descriptors) {
+            if (descriptor.kind !== 0x00)
+                continue;
+            descriptor.xidx++;
             continue;
-        descriptor.xidx++;
+        }
     }
 }

package/out/mod.d.ts

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

package/out/mod.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env deno
+#!/usr/bin/env node
 export * from "./mods/mod.js";
 import process from "node:process";
 import * as server from "./mods/server/bin.js";

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

@@ -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);
             },
@@ -265,18 +289,18 @@ function run(module, method, params, mode, maxsparks) {
                     load(module);
                 if (typeof exports[module][method] !== "function")
                     throw new Error("Not found");
-                return exports[module][method](...params);
+                return [exports[module][method](...params)];
             },
-            create: (wasmAsBytes, saltAsBytes) => {
-                const packAsBytes = pack_encode([wasmAsBytes, saltAsBytes]);
-                const digestOfWasmAsBytes = sha256_digest(wasmAsBytes);
-                const digestOfPackAsBytes = sha256_digest(packAsBytes);
-                const digestOfWasmAsHex = digestOfWasmAsBytes.toHex();
+            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}/${digestOfWasmAsHex}.wasm`))
-                    writeFileSync(`${config.scripts.path}/${digestOfWasmAsHex}.wasm`, wasmAsBytes);
+                if (!existsSync(`${config.scripts.path}/${digestOfCodeAsHex}.wasm`))
+                    writeFileSync(`${config.scripts.path}/${digestOfCodeAsHex}.wasm`, code);
                 if (!existsSync(`${config.scripts.path}/${digestOfPackAsHex}.wasm`))
-                    symlinkSync(`./${digestOfWasmAsHex}.wasm`, `${config.scripts.path}/${digestOfPackAsHex}.wasm`, "file");
+                    symlinkSync(`./${digestOfCodeAsHex}.wasm`, `${config.scripts.path}/${digestOfPackAsHex}.wasm`, "file");
                 return digestOfPackAsHex;
             }
         };
@@ -284,28 +308,30 @@ function run(module, method, params, mode, maxsparks) {
             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"] = {
@@ -344,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;
@@ -369,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.18",
+  "version": "0.0.20",
   "description": "A blockchain in your garage",
   "repository": "github:hazae41/bobine",
   "author": "hazae41",