@spacesprotocol/libveritas 0.0.0-dev.20260306102312 → 0.0.0-dev.20260306204125

package/README.md

@@ -13,30 +13,31 @@ npm install @spacesprotocol/libveritas
 ### Verifying a message
 
 ```javascript
-import { Veritas, QueryContext } from "@spacesprotocol/libveritas";
+import { Veritas, QueryContext, Message } from "@spacesprotocol/libveritas";
 
 // Load trust anchors
-const veritas = new Veritas(anchors, false);
+const veritas = new Veritas(anchors);
 
-console.log(`Anchors: ${veritas.oldest_anchor()} .. ${veritas.newest_anchor()}`);
+console.log(`Anchors: ${veritas.oldestAnchor()} .. ${veritas.newestAnchor()}`);
 
 // Build query context (empty = verify all handles)
 const ctx = new QueryContext();
-ctx.add_request("alice@bitcoin");
+ctx.addRequest("alice@bitcoin");
 
 // Verify a message (binary data from relay)
-const result = veritas.verify_message(ctx, messageBytes);
+const msg = new Message(messageBytes);
+const result = veritas.verifyMessage(ctx, msg);
 
 // Inspect verified zones
 for (const zone of result.zones()) {
   console.log(`${zone.handle()} -> ${zone.sovereignty()}`);
 
   // Store zone for later comparison
-  const bytes = zone.to_bytes();
+  const bytes = zone.toBytes();
 }
 
 // Compare zones
-const better = newerZone.is_better_than(olderZone);
+const better = newerZone.isBetterThan(olderZone);
 
 // Get certificates
 for (const cert of result.certificates()) {
@@ -57,18 +58,18 @@ let offchainBytes = OffchainData.from(rs, sig);
 // Build a message with certificates and offchain data
 let builder = new MessageBuilder([
   { name: "@bitcoin", cert: rootCertBytes },
-  { name: "alice@bitcoin", offchain_data: offchainBytes, cert: leafCertBytes },
+  { name: "alice@bitcoin", offchainData: offchainBytes, cert: leafCertBytes },
 ]);
 
 // Get the chain proof request to send to a provider
-let request = builder.chain_proof_request();
+let request = builder.chainProofRequest();
 
 // ... send request to provider, get chain proof back ...
 
 let msg = builder.build(chainProofBytes);
 
 // Serialize for transport
-let bytes = msg.to_bytes();
+let bytes = msg.toBytes();
 ```
 
 ### Updating offchain data
@@ -82,10 +83,10 @@ let sig = wallet.signSchnorr(rs.id());
 let offchainBytes = OffchainData.from(rs, sig);
 
 msg.update([
-  { name: "alice@bitcoin", offchain_data: offchainBytes },
+  { name: "alice@bitcoin", offchainData: offchainBytes },
 ]);
 
-let updatedBytes = msg.to_bytes();
+let updatedBytes = msg.toBytes();
 ```
 
 ## Building from source

package/libveritas.d.ts

@@ -148,14 +148,15 @@ export class Veritas {
     free(): void;
     [Symbol.dispose](): void;
     is_finalized(commitment_height: number): boolean;
-    constructor(anchors: any, dev_mode: boolean);
+    constructor(anchors: any);
     newest_anchor(): number;
     oldest_anchor(): number;
     sovereignty_for(commitment_height: number): string;
     /**
      * Verify a message against a query context.
      */
-    verify_message(ctx: QueryContext, msg: Uint8Array): VerifiedMessage;
+    verify_message(ctx: QueryContext, msg: Message): VerifiedMessage;
+    static withDevMode(anchors: any): Veritas;
 }
 
 export class Zone {

package/libveritas.js

@@ -352,6 +352,13 @@ if (Symbol.dispose) VerifiedMessage.prototype[Symbol.dispose] = VerifiedMessage.
 exports.VerifiedMessage = VerifiedMessage;
 
 class Veritas {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Veritas.prototype);
+        obj.__wbg_ptr = ptr;
+        VeritasFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -372,10 +379,9 @@ class Veritas {
     }
     /**
      * @param {any} anchors
-     * @param {boolean} dev_mode
      */
-    constructor(anchors, dev_mode) {
-        const ret = wasm.veritas_new(anchors, dev_mode);
+    constructor(anchors) {
+        const ret = wasm.veritas_new(anchors);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -416,19 +422,29 @@ class Veritas {
     /**
      * Verify a message against a query context.
      * @param {QueryContext} ctx
-     * @param {Uint8Array} msg
+     * @param {Message} msg
      * @returns {VerifiedMessage}
      */
     verify_message(ctx, msg) {
         _assertClass(ctx, QueryContext);
-        const ptr0 = passArray8ToWasm0(msg, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.veritas_verify_message(this.__wbg_ptr, ctx.__wbg_ptr, ptr0, len0);
+        _assertClass(msg, Message);
+        const ret = wasm.veritas_verify_message(this.__wbg_ptr, ctx.__wbg_ptr, msg.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return VerifiedMessage.__wrap(ret[0]);
     }
+    /**
+     * @param {any} anchors
+     * @returns {Veritas}
+     */
+    static withDevMode(anchors) {
+        const ret = wasm.veritas_withDevMode(anchors);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Veritas.__wrap(ret[0]);
+    }
 }
 if (Symbol.dispose) Veritas.prototype[Symbol.dispose] = Veritas.prototype.free;
 exports.Veritas = Veritas;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spacesprotocol/libveritas",
-  "version": "0.0.0-dev.20260306102312",
+  "version": "0.0.0-dev.20260306204125",
   "files": [
     "libveritas_bg.wasm",
     "libveritas.js",