@hazae41/bobine 0.0.8 → 0.0.10

package/README.md

@@ -17,9 +17,9 @@ https://bobine.tech/
 
 \* There are no built-in accounting concepts, only pure generic APIs for cryptography and storage
 
-## Running
+## Usage
 
-### Binary
+### Running the server
 
 Install the binary with Deno
 
@@ -58,13 +58,15 @@ Run the server
 bobine serve --env=./.env.local
 ```
 
-### Library
+Or you can install `@hazae41/bobine` and use the `serve()` function
 
-Install `@hazae41/bobine` and use the `serve()` function
+### Making your own module
 
-## HTTP API
+You can clone my [AssemblyScript starter](https://github.com/hazae41/create-bobine-assemblyscript-module) to get started with AssemblyScript
 
-### POST /api/create
+### Using the HTTP API
+
+#### POST /api/create
 
 Creates a new module using some WebAssembly code and some unique salt
 
@@ -76,7 +78,7 @@ Accepts a form data with the following fields
 
 - `effort` as bytes = some unique 32 bytes whose sha256 `hash` validates `((2n ** 256n) / BigInt("0x" + hash.toHex())) > (code.length + salt.length)`
 
-### POST /api/execute
+#### POST /api/execute
 
 Execute some function on a module
 
@@ -90,7 +92,7 @@ Accepts a form data with the following fields
 
 - `effort` as bytes =  some unique 32 bytes whose sha256 `hash` whose result in `((2n ** 256n) / BigInt("0x" + hash.toHex()))` will be the maximum number of sparks (gas) used
 
-### POST /api/simulate
+#### POST /api/simulate
 
 Simulate some function on a module (it won't write anything to storage and will execute in mode `2` so verifications such as signatures can be skipped)
 
@@ -104,11 +106,11 @@ Accepts a form data with the following fields
 
 - `effort` as bytes =  some unique 32 bytes whose sha256 `hash` whose result in `((2n ** 256n) / BigInt("0x" + hash.toHex()))` will be the maximum number of sparks (gas) used
 
-## WebAssembly API
+### Using the WebAssembly API
 
 The WebAssembly VM extensively uses reference types for its API and for module-to-module communication
 
-### AssemblyScript
+#### Using the WebAssembly API via AssemblyScript
 
 You can use [stdbob](https://github.com/hazae41/stdbob) to easily import AssemblyScript declarations for all internal modules
 
@@ -126,9 +128,7 @@ And you can declare external modules by using the module address as hex
 declare function add(x: externref, y: externref): externref
 ```
 
-### All internal modules
-
-#### blobs
+#### Blobs module
 
 You can pass bytes between modules by storing them in the blob storage and loading them via reference
 
@@ -142,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 module
 
 You can work with infinite-precision bigints
 
@@ -168,7 +168,7 @@ You can work with infinite-precision bigints
 
 - `bigints.from_base10(base16: blobref): bigintref` = convert base10 utf8 bytes to bigint
 
-#### packs
+#### Packs module
 
 You can pack various arguments (numbers, refs) into a pack which can be passed between modules and/or encoded/decoded into bytes
 
@@ -225,7 +225,7 @@ function writePack(pack: packref) {
 
 - `packs.length(pack: packref): i32` = get the length of a pack
 
-#### env
+#### Environment module
 
 Get infos about the executing environment
 
@@ -233,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 module
 
 Modules are identified by their address as a blob of bytes (pure sha256-output 32-length bytes without any encoding)
 
@@ -245,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 module
 
 You can use a private storage (it works like storage and events at the same time)
 
@@ -253,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
+#### SHA-256 module
 
 Use the SHA-256 hashing algorithm
 
 - `sha256.digest(payload: blobref): blobref` = hash the payload and returns the digest
 
-#### ed25519
+#### Ed25519 module
 
 Use the Ed25519 signing algorithm
 
@@ -267,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 module (experimental)
 
 - `symbols.create(): symbolref` = create a unique reference that can be passed around
 
-#### refs (experimental)
+#### References module (experimental)
 
 - `refs.numerize(ref: symbolref/blobref/packref): i32` = translate any reference into a unique private pointer that can be stored into data structures
 

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

package/out/libs/packs/mod.js

@@ -1,4 +1,4 @@
-/// <reference types="../bytes/lib.d.ts"/>
+// deno-lint-ignore-file no-namespace
 export class Pack {
     values;
     constructor(values) {
@@ -11,22 +11,27 @@ export class Pack {
                 size += 1;
                 continue;
             }
-            if (typeof value === "number") {
-                size += 1 + 4;
+            if (value instanceof Pack) {
+                size += 1 + value.sizeOrThrow();
                 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 text = value.toString(16);
+                const data = Uint8Array.fromHex(text.length % 2 === 1 ? "0" + text : text);
+                size += 1 + 4 + data.length;
                 continue;
             }
             throw new Error("Unknown pack value");
@@ -40,17 +45,14 @@ export class Pack {
                 cursor.writeUint8OrThrow(1);
                 continue;
             }
-            if (typeof value === "number") {
+            if (value instanceof Pack) {
                 cursor.writeUint8OrThrow(2);
-                cursor.writeFloat64OrThrow(value, true);
+                value.writeOrThrow(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 +61,19 @@ 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 text = value.toString(16);
+                const data = Uint8Array.fromHex(text.length % 2 === 1 ? "0" + text : text);
+                cursor.writeUint32OrThrow(data.length, true);
+                cursor.writeOrThrow(data);
                 continue;
             }
             throw new Error("Unknown pack value");
@@ -82,13 +94,11 @@ export class Pack {
                 continue;
             }
             if (type === 2) {
-                values.push(cursor.readFloat64OrThrow(true));
+                values.push(Pack.readOrThrow(cursor));
                 continue;
             }
             if (type === 3) {
-                const size = cursor.readUint32OrThrow(true);
-                const data = cursor.readOrThrow(size);
-                values.push(BigInt("0x" + data.toHex()));
+                values.push(cursor.readFloat64OrThrow(true));
                 continue;
             }
             if (type === 4) {
@@ -97,7 +107,15 @@ export class Pack {
                 continue;
             }
             if (type === 5) {
-                values.push(Pack.readOrThrow(cursor));
+                const size = cursor.readUint32OrThrow(true);
+                const data = cursor.readOrThrow(size);
+                values.push(new TextDecoder().decode(data));
+                continue;
+            }
+            if (type === 6) {
+                const size = cursor.readUint32OrThrow(true);
+                const data = cursor.readOrThrow(size);
+                values.push(BigInt("0x" + data.toHex()));
                 continue;
             }
             throw new Error("Unknown pack type");

package/out/mod.js

@@ -15,24 +15,9 @@ export async function main(args) {
             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]");
+    console.log("serve [--env=<env file as path>] [--port=<port>] [--dev]");
     return;
 }
 if (import.meta.main) {

package/out/mods/server/bin.js

@@ -2,7 +2,7 @@ import { readFileSync } from "node:fs";
 import process from "node:process";
 import { serveWithEnv } from "./mod.js";
 export async function main(args) {
-    const config = {};
+    const options = {};
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
         if (arg.startsWith("--env=")) {
@@ -10,15 +10,15 @@ export async function main(args) {
             continue;
         }
         if (arg.startsWith("--port=")) {
-            config.port = Number(arg.slice("--port=".length));
+            options.port = Number(arg.slice("--port=".length));
             continue;
         }
         if (arg.startsWith("--cert=")) {
-            config.cert = readFileSync(arg.slice("--cert=".length), "utf8");
+            options.cert = readFileSync(arg.slice("--cert=".length), "utf8");
             continue;
         }
         if (arg.startsWith("--key=")) {
-            config.key = readFileSync(arg.slice("--key=".length), "utf8");
+            options.key = readFileSync(arg.slice("--key=".length), "utf8");
             continue;
         }
         if (arg === "--dev=true") {
@@ -35,7 +35,7 @@ export async function main(args) {
         }
         throw new Error(`Unknown argument: ${arg}`);
     }
-    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 { 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, } = options;
     const server = await serveWithEnv();
     const route = async (request) => {
         if (request.method === "OPTIONS")

package/out/mods/worker/bin.js

@@ -89,14 +89,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,17 +106,55 @@ 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"] = {

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@hazae41/bobine",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "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"