@hazae41/bobine 0.0.12 → 0.0.17

package/README.md

@@ -2,9 +2,7 @@
 
 A blockchain in your garage
 
-https://bobine.tech/
-
-[**📦 NPM**](https://www.npmjs.com/package/@hazae41/bobine) • [**📦 JSR**](https://jsr.io/@hazae41/bobine)
+[**🌐 Website**](https://bobine.tech/) • [**📦 NPM**](https://www.npmjs.com/package/@hazae41/bobine)
 
 ## Features
 
@@ -24,7 +22,7 @@ https://bobine.tech/
 Install the binary with Deno
 
 ```bash
-deno install -gf -A jsr:@hazae41/bobine
+deno install -gf -A npm:@hazae41/bobine
 ```
 
 Generate an Ed25519 keypair by running the following code in your browser/deno/node/bun console

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

@@ -0,0 +1,13 @@
+import type { Cursor } from "@hazae41/cursor";
+export type Packable = null | number | Uint8Array | string | bigint | Array<Packable>;
+export declare class Packed {
+    readonly value: Packable;
+    constructor(value: Packable);
+    sizeOrThrow(): number;
+    writeOrThrow(cursor: Cursor): void;
+}
+export declare namespace Packed {
+    function readOrThrow(cursor: Cursor): Packable;
+    function sizeOrThrow(value: Packable): number;
+    function writeOrThrow(value: Packable, cursor: Cursor): void;
+}

package/out/libs/packed/mod.js

@@ -0,0 +1,114 @@
+// deno-lint-ignore-file no-namespace
+export class Packed {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    sizeOrThrow() {
+        return Packed.sizeOrThrow(this.value);
+    }
+    writeOrThrow(cursor) {
+        Packed.writeOrThrow(this.value, cursor);
+    }
+}
+(function (Packed) {
+    function readOrThrow(cursor) {
+        const type = cursor.readUint8OrThrow();
+        if (type === 0)
+            return null;
+        if (type === 1)
+            return cursor.readFloat64OrThrow(true);
+        if (type === 2)
+            return cursor.readOrThrow(cursor.readUint32OrThrow(true));
+        if (type === 3) {
+            const size = cursor.readUint32OrThrow(true);
+            const data = cursor.readOrThrow(size);
+            return new TextDecoder().decode(data);
+        }
+        if (type === 4) {
+            const negative = cursor.readUint8OrThrow();
+            const size = cursor.readUint32OrThrow(true);
+            const data = cursor.readOrThrow(size);
+            const absolute = BigInt("0x" + data.toHex());
+            return negative ? -absolute : absolute;
+        }
+        if (type === 5) {
+            const length = cursor.readUint32OrThrow(true);
+            const values = new Array(length);
+            for (let i = 0; i < length; i++)
+                values[i] = readOrThrow(cursor);
+            return values;
+        }
+        throw new Error("Unknown pack type");
+    }
+    Packed.readOrThrow = readOrThrow;
+    function sizeOrThrow(value) {
+        if (value == null)
+            return 1;
+        if (typeof value === "number")
+            return 1 + 4;
+        if (value instanceof Uint8Array)
+            return 1 + 4 + value.length;
+        if (typeof value === "string")
+            return 1 + 4 + new TextEncoder().encode(value).length;
+        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);
+            return 1 + 1 + 4 + data.length;
+        }
+        if (Array.isArray(value)) {
+            let size = 0;
+            size += 1;
+            size += 4;
+            for (const subvalue of value)
+                size += sizeOrThrow(subvalue);
+            return size;
+        }
+        throw new Error("Unknown pack value");
+    }
+    Packed.sizeOrThrow = sizeOrThrow;
+    function writeOrThrow(value, cursor) {
+        if (value == null) {
+            cursor.writeUint8OrThrow(0);
+            return;
+        }
+        if (typeof value === "number") {
+            cursor.writeUint8OrThrow(1);
+            cursor.writeFloat64OrThrow(value, true);
+            return;
+        }
+        if (value instanceof Uint8Array) {
+            cursor.writeUint8OrThrow(2);
+            cursor.writeUint32OrThrow(value.length, true);
+            cursor.writeOrThrow(value);
+            return;
+        }
+        if (typeof value === "string") {
+            cursor.writeUint8OrThrow(3);
+            const data = new TextEncoder().encode(value);
+            cursor.writeUint32OrThrow(data.length, true);
+            cursor.writeOrThrow(data);
+            return;
+        }
+        if (typeof value === "bigint") {
+            cursor.writeUint8OrThrow(4);
+            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);
+            return;
+        }
+        if (Array.isArray(value)) {
+            cursor.writeUint8OrThrow(5);
+            cursor.writeUint32OrThrow(value.length, true);
+            for (const subvalue of value)
+                writeOrThrow(subvalue, cursor);
+            return;
+        }
+        throw new Error("Unknown pack value");
+    }
+    Packed.writeOrThrow = writeOrThrow;
+})(Packed || (Packed = {}));

package/out/mods/helper/bin.js

@@ -1,3 +1,4 @@
+/// <reference lib="webworker" />
 import { RpcMethodNotFoundError } from "@hazae41/jsonrpc";
 import { connect } from "@tursodatabase/database";
 import { runAsImmediateOrThrow } from "../../libs/sql/mod.js";
@@ -10,10 +11,10 @@ self.addEventListener("message", async (event) => {
         const request = event.data;
         if (request.method === "storage_set") {
             return await runAsImmediateOrThrow(database, async (database) => {
-                const [module, method, args, events] = event.data.params;
+                const [module, method, args, writes] = event.data.params;
                 const moment = await database.prepare(`INSERT INTO moments (epoch, module, method, params) VALUES (0, ?, ?, ?);`).run(module, method, args);
                 const writer = database.prepare(`INSERT INTO events (moment, module, key, value) VALUES (?, ?, ?, ?);`);
-                for (const [module, key, value] of events)
+                for (const [module, key, value] of writes)
                     await writer.run(moment.lastInsertRowid, module, key, value);
                 request.result[0] = 1;
                 request.result[1] = moment.lastInsertRowid;

package/out/mods/server/bin.js

@@ -1,3 +1,4 @@
+/// <reference lib="deno.ns" />
 import { readFileSync } from "node:fs";
 import process from "node:process";
 import { serveWithEnv } from "./mod.js";

package/out/mods/server/mod.js

@@ -58,7 +58,7 @@ import { connect } from "@tursodatabase/database";
 import { existsSync, mkdirSync, symlinkSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 import process from "node:process";
-import { Pack } from "../../libs/packs/mod.js";
+import { Packed } from "../../libs/packed/mod.js";
 export async function serveWithEnv(prefix = "") {
     const { DATABASE_PATH = process.env[prefix + "DATABASE_PATH"], SCRIPTS_PATH = process.env[prefix + "SCRIPTS_PATH"], ED25519_PRIVATE_KEY_HEX = process.env[prefix + "ED25519_PRIVATE_KEY_HEX"], ED25519_PUBLIC_KEY_HEX = process.env[prefix + "ED25519_PUBLIC_KEY_HEX"], } = {};
     if (DATABASE_PATH == null)
@@ -93,6 +93,7 @@ export async function serve(config) {
     module TEXT NOT NULL,
     
     key TEXT NOT NULL,
+
     value BLOB NOT NULL
   );`);
     await database.exec(`CREATE TABLE IF NOT EXISTS moments (
@@ -101,7 +102,9 @@ export async function serve(config) {
     epoch INTEGER NOT NULL,
 
     module TEXT NOT NULL,
+
     method TEXT NOT NULL,
+    
     params BLOB NOT NULL
   );`);
     await database.close();
@@ -141,7 +144,7 @@ export async function serve(config) {
                 const sparksAsBigInt = (2n ** 256n) / BigInt("0x" + new Uint8Array(await crypto.subtle.digest("SHA-256", effortAsBytes)).toHex());
                 if (sparksAsBigInt < (wasmAsBytes.length + saltAsBytes.length))
                     return Response.json(null, { status: 402 });
-                const packAsBytes = Writable.writeToBytesOrThrow(new Pack([wasmAsBytes, saltAsBytes]));
+                const packAsBytes = Writable.writeToBytesOrThrow(new Packed([wasmAsBytes, saltAsBytes]));
                 const digestOfWasmAsBytes = new Uint8Array(await crypto.subtle.digest("SHA-256", wasmAsBytes));
                 const digestOfPackAsBytes = new Uint8Array(await crypto.subtle.digest("SHA-256", packAsBytes));
                 const digestOfWasmAsHex = digestOfWasmAsBytes.toHex();

package/out/mods/worker/bin.js

@@ -1,11 +1,12 @@
 // deno-lint-ignore-file no-explicit-any no-unused-vars ban-unused-ignore
+/// <reference lib="webworker" />
 import { Readable, Writable } from "@hazae41/binary";
 import { RpcErr, RpcError, RpcMethodNotFoundError, RpcOk } from "@hazae41/jsonrpc";
 import * as Wasm from "@hazae41/wasm";
 import { Buffer } from "node:buffer";
 import { existsSync, readFileSync, symlinkSync, writeFileSync } from "node:fs";
 import { meter } from "../../libs/metering/mod.js";
-import { Pack } from "../../libs/packs/mod.js";
+import { Packed } from "../../libs/packed/mod.js";
 const config = await fetch(self.name).then(res => res.json());
 const helper = new Worker(import.meta.resolve("../helper/bin.js"), { name: self.name, type: "module" });
 function run(module, method, params, mode, maxsparks) {
@@ -15,11 +16,11 @@ function run(module, method, params, mode, maxsparks) {
     const caches = new Map();
     const reads = new Array();
     const writes = new Array();
-    const pack_encode = (pack) => {
-        return Writable.writeToBytesOrThrow(new Pack(pack));
+    const pack_encode = (value) => {
+        return Writable.writeToBytesOrThrow(new Packed(value));
     };
     const pack_decode = (bytes) => {
-        return Readable.readFromBytesOrThrow(Pack, bytes);
+        return Readable.readFromBytesOrThrow(Packed, bytes);
     };
     const sparks_consume = (amount) => {
         sparks += amount;
@@ -116,15 +117,21 @@ function run(module, method, params, mode, maxsparks) {
             from_base16: (text) => {
                 return Uint8Array.fromHex(text);
             },
-            to_base16: (bytes) => {
-                return bytes.toHex();
+            to_base16: (blob) => {
+                return blob.toHex();
             },
             from_base64: (text) => {
                 return Uint8Array.fromBase64(text);
             },
-            to_base64: (bytes) => {
-                return bytes.toBase64();
+            to_base64: (blob) => {
+                return blob.toBase64();
             },
+            encode: (value) => {
+                return pack_encode(value);
+            },
+            decode: (blob) => {
+                return pack_decode(blob);
+            }
         };
         imports["texts"] = {
             length: (text) => {
@@ -173,12 +180,6 @@ function run(module, method, params, mode, maxsparks) {
                 if (value === undefined)
                     throw new Error("Not found");
                 return value;
-            },
-            encode: (pack) => {
-                return pack_encode(pack);
-            },
-            decode: (blob) => {
-                return pack_decode(blob);
             }
         };
         imports["bigints"] = {
@@ -272,7 +273,7 @@ function run(module, method, params, mode, maxsparks) {
                     load(moduleAsString);
                 if (typeof exports[moduleAsString][methodAsString] !== "function")
                     throw new Error("Not found");
-                return new Pack([exports[moduleAsString][methodAsString](...paramsAsPack.values)]);
+                return exports[moduleAsString][methodAsString](...paramsAsPack);
             },
             load: (moduleAsBytes) => {
                 return readFileSync(`${config.scripts.path}/${moduleAsBytes.toHex()}.wasm`);
@@ -379,8 +380,11 @@ function run(module, method, params, mode, maxsparks) {
     const { instance } = load(module);
     if (typeof instance.exports[method] !== "function")
         throw new Error("Not found");
-    const returned = [instance.exports[method](...pack_decode(params))];
-    if (mode !== 2)
+    const args = pack_decode(params);
+    if (!Array.isArray(args))
+        throw new Error("Params is not an array");
+    const returned = instance.exports[method](...args);
+    if (mode !== 1)
         return pack_encode([logs, reads, writes, returned, sparks]);
     if (writes.length) {
         const result = new Int32Array(new SharedArrayBuffer(4 + 4));

package/package.json

@@ -1,15 +1,13 @@
 {
   "type": "module",
   "name": "@hazae41/bobine",
-  "version": "0.0.12",
+  "version": "0.0.17",
   "description": "A blockchain in your garage",
   "repository": "github:hazae41/bobine",
   "author": "hazae41",
   "license": "MIT",
   "scripts": {
     "examine": "deno lint ./src && deno check ./src && deno test -R ./src",
-    "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/mod.ts serve --env=./.env.local",
     "develop": "deno run -A ./src/mod.ts serve --env=./.env.local --dev"

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

@@ -1,13 +0,0 @@
-import type { Cursor } from "@hazae41/cursor";
-export declare class Pack {
-    readonly values: Array<Pack.Value>;
-    constructor(values: Array<Pack.Value>);
-    sizeOrThrow(): number;
-    writeOrThrow(cursor: Cursor): void;
-}
-export declare namespace 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,139 +0,0 @@
-// 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 values) {
-            if (value == null) {
-                size += 1;
-                continue;
-            }
-            if (Array.isArray(value)) {
-                size += 1 + sizeOrThrow(value);
-                continue;
-            }
-            if (typeof value === "number") {
-                size += 1 + 4;
-                continue;
-            }
-            if (value instanceof Uint8Array) {
-                size += 1 + 4 + value.length;
-                continue;
-            }
-            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");
-        }
-        size += 1;
-        return size;
-    }
-    Pack.sizeOrThrow = sizeOrThrow;
-    function writeOrThrow(values, cursor) {
-        for (const value of values) {
-            if (value == null) {
-                cursor.writeUint8OrThrow(1);
-                continue;
-            }
-            if (Array.isArray(value)) {
-                cursor.writeUint8OrThrow(2);
-                writeOrThrow(value, cursor);
-                continue;
-            }
-            if (typeof value === "number") {
-                cursor.writeUint8OrThrow(3);
-                cursor.writeFloat64OrThrow(value, true);
-                continue;
-            }
-            if (value instanceof Uint8Array) {
-                cursor.writeUint8OrThrow(4);
-                cursor.writeUint32OrThrow(value.length, true);
-                cursor.writeOrThrow(value);
-                continue;
-            }
-            if (typeof value === "string") {
-                cursor.writeUint8OrThrow(5);
-                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");
-        }
-        cursor.writeUint8OrThrow(0);
-        return;
-    }
-    Pack.writeOrThrow = writeOrThrow;
-})(Pack || (Pack = {}));