@spacesprotocol/libveritas 0.0.0-dev.20260225143024 → 0.0.0-dev.20260306131110

package/README.md

@@ -0,0 +1,98 @@
+# @spacesprotocol/libveritas
+
+JavaScript/WASM bindings for [libveritas](https://github.com/spacesprotocol/libveritas) — stateless verification for Bitcoin handles using the [Spaces protocol](https://spacesprotocol.org).
+
+## Installation
+
+```bash
+npm install @spacesprotocol/libveritas
+```
+
+## Usage
+
+### Verifying a message
+
+```javascript
+import { Veritas, QueryContext } from "@spacesprotocol/libveritas";
+
+// Load trust anchors
+const veritas = new Veritas(anchors);
+
+console.log(`Anchors: ${veritas.oldestAnchor()} .. ${veritas.newestAnchor()}`);
+
+// Build query context (empty = verify all handles)
+const ctx = new QueryContext();
+ctx.addRequest("alice@bitcoin");
+
+// Verify a message (binary data from relay)
+const result = veritas.verifyMessage(ctx, messageBytes);
+
+// Inspect verified zones
+for (const zone of result.zones()) {
+  console.log(`${zone.handle()} -> ${zone.sovereignty()}`);
+
+  // Store zone for later comparison
+  const bytes = zone.toBytes();
+}
+
+// Compare zones
+const better = newerZone.isBetterThan(olderZone);
+
+// Get certificates
+for (const cert of result.certificates()) {
+  console.log(cert);
+}
+```
+
+### Building a message
+
+```javascript
+import { MessageBuilder, RecordSet, OffchainData } from "@spacesprotocol/libveritas";
+
+// Construct offchain data
+let rs = new RecordSet(1, { nostr: "npub1...", ipv4: "127.0.0.1" });
+let sig = wallet.signSchnorr(rs.id());
+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", offchainData: offchainBytes, cert: leafCertBytes },
+]);
+
+// Get the chain proof request to send to a provider
+let request = builder.chainProofRequest();
+
+// ... send request to provider, get chain proof back ...
+
+let msg = builder.build(chainProofBytes);
+
+// Serialize for transport
+let bytes = msg.toBytes();
+```
+
+### Updating offchain data
+
+```javascript
+// Update offchain data on a verified message (no cert changes)
+let msg = result.message();
+
+let rs = new RecordSet(2, { nostr: "npub1new..." });
+let sig = wallet.signSchnorr(rs.id());
+let offchainBytes = OffchainData.from(rs, sig);
+
+msg.update([
+  { name: "alice@bitcoin", offchainData: offchainBytes },
+]);
+
+let updatedBytes = msg.toBytes();
+```
+
+## Building from source
+
+Requires [Rust](https://rustup.rs/) and [wasm-pack](https://rustwasm.github.io/wasm-pack/):
+
+```bash
+cargo install wasm-pack
+wasm-pack build bindings/wasm --target web
+```

package/libveritas.d.ts

@@ -1,6 +1,82 @@
 /* tslint:disable */
 /* eslint-disable */
 
+/**
+ * A message containing chain proofs and handle data.
+ */
+export class Message {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Decode a message from borsh bytes.
+     */
+    constructor(bytes: Uint8Array);
+    /**
+     * Serialize the message to borsh bytes.
+     */
+    to_bytes(): Uint8Array;
+    /**
+     * Update offchain data on this message.
+     *
+     * Accepts a JS array of data update entries:
+     * ```js
+     * msg.update([
+     *   { name: "alice@bitcoin", offchain_data: Uint8Array },
+     *   { name: "@bitcoin", delegate_offchain_data: Uint8Array }
+     * ])
+     * ```
+     *
+     * To update certificates, construct a new message instead.
+     */
+    update(updates: any): void;
+}
+
+/**
+ * Builder for constructing messages from update requests and chain proofs.
+ */
+export class MessageBuilder {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Build the message from a borsh-encoded ChainProof.
+     *
+     * Consumes the builder — cannot be called twice.
+     */
+    build(chain_proof: Uint8Array): Message;
+    /**
+     * Returns the chain proof request as a JS object.
+     *
+     * Send this to the provider/fabric to get the chain proofs needed for `build()`.
+     */
+    chain_proof_request(): any;
+    /**
+     * Create a builder from a JS array of update requests.
+     *
+     * ```js
+     * let builder = new MessageBuilder([
+     *   { name: "@bitcoin", offchain_data: Uint8Array, cert: Uint8Array },
+     *   { name: "alice@bitcoin", offchain_data: Uint8Array, cert: Uint8Array }
+     * ])
+     * ```
+     */
+    constructor(requests: any);
+}
+
+/**
+ * Helpers for constructing OffchainData.
+ */
+export class OffchainData {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Create borsh-encoded OffchainData from a RecordSet and a 64-byte Schnorr signature.
+     *
+     * Consumes the RecordSet.
+     */
+    static from(record_set: RecordSet, signature: Uint8Array): Uint8Array;
+}
+
 export class QueryContext {
     free(): void;
     [Symbol.dispose](): void;
@@ -16,6 +92,28 @@ export class QueryContext {
     constructor();
 }
 
+/**
+ * Serialized records ready to be signed.
+ *
+ * ```js
+ * let rs = new RecordSet(1, { nostr: "npub1...", ipv4: "127.0.0.1" });
+ * let sig = wallet.signSchnorr(rs.id());
+ * let offchainBytes = OffchainData.from(rs, sig);
+ * ```
+ */
+export class RecordSet {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * The 32-byte hash to sign.
+     */
+    id(): Uint8Array;
+    /**
+     * Create a record set from a sequence number and a JS object of key-value pairs.
+     */
+    constructor(seq: number, records: any);
+}
+
 /**
  * Result of verifying a message.
  */
@@ -32,17 +130,25 @@ export class VerifiedMessage {
      * All certificates as a JS array.
      */
     certificates(): any;
+    /**
+     * Get the verified message for rebroadcasting or updating.
+     */
+    message(): Message;
+    /**
+     * Get the verified message as borsh bytes.
+     */
+    message_bytes(): Uint8Array;
     /**
      * All verified zones.
      */
-    zones(): VeritasZone[];
+    zones(): Zone[];
 }
 
 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;
@@ -50,15 +156,16 @@ export class Veritas {
      * Verify a message against a query context.
      */
     verify_message(ctx: QueryContext, msg: Uint8Array): VerifiedMessage;
+    static withDevMode(anchors: any): Veritas;
 }
 
-export class VeritasZone {
+export class Zone {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
     anchor(): number;
     handle(): string;
-    is_better_than(other: VeritasZone): boolean;
+    is_better_than(other: Zone): boolean;
     sovereignty(): string;
     to_bytes(): Uint8Array;
     /**
@@ -73,9 +180,9 @@ export class VeritasZone {
 export function decode_certificate(bytes: Uint8Array): any;
 
 /**
- * Decode stored zone bytes to a VeritasZone object.
+ * Decode stored zone bytes to a Zone object.
  */
-export function decode_zone(bytes: Uint8Array): VeritasZone;
+export function decode_zone(bytes: Uint8Array): Zone;
 
 /**
  * Hash a message with the Spaces signed-message prefix (SHA256).

package/libveritas.js

@@ -1,5 +1,180 @@
 /* @ts-self-types="./libveritas.d.ts" */
 
+/**
+ * A message containing chain proofs and handle data.
+ */
+class Message {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Message.prototype);
+        obj.__wbg_ptr = ptr;
+        MessageFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MessageFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_message_free(ptr, 0);
+    }
+    /**
+     * Decode a message from borsh bytes.
+     * @param {Uint8Array} bytes
+     */
+    constructor(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.message_from_bytes(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        MessageFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Serialize the message to borsh bytes.
+     * @returns {Uint8Array}
+     */
+    to_bytes() {
+        const ret = wasm.message_to_bytes(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Update offchain data on this message.
+     *
+     * Accepts a JS array of data update entries:
+     * ```js
+     * msg.update([
+     *   { name: "alice@bitcoin", offchain_data: Uint8Array },
+     *   { name: "@bitcoin", delegate_offchain_data: Uint8Array }
+     * ])
+     * ```
+     *
+     * To update certificates, construct a new message instead.
+     * @param {any} updates
+     */
+    update(updates) {
+        const ret = wasm.message_update(this.__wbg_ptr, updates);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+}
+if (Symbol.dispose) Message.prototype[Symbol.dispose] = Message.prototype.free;
+exports.Message = Message;
+
+/**
+ * Builder for constructing messages from update requests and chain proofs.
+ */
+class MessageBuilder {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MessageBuilderFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_messagebuilder_free(ptr, 0);
+    }
+    /**
+     * Build the message from a borsh-encoded ChainProof.
+     *
+     * Consumes the builder — cannot be called twice.
+     * @param {Uint8Array} chain_proof
+     * @returns {Message}
+     */
+    build(chain_proof) {
+        const ptr0 = passArray8ToWasm0(chain_proof, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.messagebuilder_build(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Message.__wrap(ret[0]);
+    }
+    /**
+     * Returns the chain proof request as a JS object.
+     *
+     * Send this to the provider/fabric to get the chain proofs needed for `build()`.
+     * @returns {any}
+     */
+    chain_proof_request() {
+        const ret = wasm.messagebuilder_chain_proof_request(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Create a builder from a JS array of update requests.
+     *
+     * ```js
+     * let builder = new MessageBuilder([
+     *   { name: "@bitcoin", offchain_data: Uint8Array, cert: Uint8Array },
+     *   { name: "alice@bitcoin", offchain_data: Uint8Array, cert: Uint8Array }
+     * ])
+     * ```
+     * @param {any} requests
+     */
+    constructor(requests) {
+        const ret = wasm.messagebuilder_new(requests);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        MessageBuilderFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) MessageBuilder.prototype[Symbol.dispose] = MessageBuilder.prototype.free;
+exports.MessageBuilder = MessageBuilder;
+
+/**
+ * Helpers for constructing OffchainData.
+ */
+class OffchainData {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        OffchainDataFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_offchaindata_free(ptr, 0);
+    }
+    /**
+     * Create borsh-encoded OffchainData from a RecordSet and a 64-byte Schnorr signature.
+     *
+     * Consumes the RecordSet.
+     * @param {RecordSet} record_set
+     * @param {Uint8Array} signature
+     * @returns {Uint8Array}
+     */
+    static from(record_set, signature) {
+        _assertClass(record_set, RecordSet);
+        const ptr0 = passArray8ToWasm0(signature, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.offchaindata_from(record_set.__wbg_ptr, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v2;
+    }
+}
+if (Symbol.dispose) OffchainData.prototype[Symbol.dispose] = OffchainData.prototype.free;
+exports.OffchainData = OffchainData;
+
 class QueryContext {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -46,6 +221,57 @@ class QueryContext {
 if (Symbol.dispose) QueryContext.prototype[Symbol.dispose] = QueryContext.prototype.free;
 exports.QueryContext = QueryContext;
 
+/**
+ * Serialized records ready to be signed.
+ *
+ * ```js
+ * let rs = new RecordSet(1, { nostr: "npub1...", ipv4: "127.0.0.1" });
+ * let sig = wallet.signSchnorr(rs.id());
+ * let offchainBytes = OffchainData.from(rs, sig);
+ * ```
+ */
+class RecordSet {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RecordSetFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_recordset_free(ptr, 0);
+    }
+    /**
+     * The 32-byte hash to sign.
+     * @returns {Uint8Array}
+     */
+    id() {
+        const ret = wasm.recordset_id(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Create a record set from a sequence number and a JS object of key-value pairs.
+     * @param {number} seq
+     * @param {any} records
+     */
+    constructor(seq, records) {
+        const ret = wasm.recordset_new(seq, records);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        RecordSetFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) RecordSet.prototype[Symbol.dispose] = RecordSet.prototype.free;
+exports.RecordSet = RecordSet;
+
 /**
  * Result of verifying a message.
  */
@@ -93,9 +319,27 @@ class VerifiedMessage {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Get the verified message for rebroadcasting or updating.
+     * @returns {Message}
+     */
+    message() {
+        const ret = wasm.verifiedmessage_message(this.__wbg_ptr);
+        return Message.__wrap(ret);
+    }
+    /**
+     * Get the verified message as borsh bytes.
+     * @returns {Uint8Array}
+     */
+    message_bytes() {
+        const ret = wasm.verifiedmessage_message_bytes(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
     /**
      * All verified zones.
-     * @returns {VeritasZone[]}
+     * @returns {Zone[]}
      */
     zones() {
         const ret = wasm.verifiedmessage_zones(this.__wbg_ptr);
@@ -108,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;
@@ -128,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]);
         }
@@ -185,33 +435,44 @@ class Veritas {
         }
         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;
 
-class VeritasZone {
+class Zone {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(VeritasZone.prototype);
+        const obj = Object.create(Zone.prototype);
         obj.__wbg_ptr = ptr;
-        VeritasZoneFinalization.register(obj, obj.__wbg_ptr, obj);
+        ZoneFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        VeritasZoneFinalization.unregister(this);
+        ZoneFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_veritaszone_free(ptr, 0);
+        wasm.__wbg_zone_free(ptr, 0);
     }
     /**
      * @returns {number}
      */
     anchor() {
-        const ret = wasm.veritaszone_anchor(this.__wbg_ptr);
+        const ret = wasm.zone_anchor(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -221,7 +482,7 @@ class VeritasZone {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.veritaszone_handle(this.__wbg_ptr);
+            const ret = wasm.zone_handle(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -230,12 +491,12 @@ class VeritasZone {
         }
     }
     /**
-     * @param {VeritasZone} other
+     * @param {Zone} other
      * @returns {boolean}
      */
     is_better_than(other) {
-        _assertClass(other, VeritasZone);
-        const ret = wasm.veritaszone_is_better_than(this.__wbg_ptr, other.__wbg_ptr);
+        _assertClass(other, Zone);
+        const ret = wasm.zone_is_better_than(this.__wbg_ptr, other.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -248,7 +509,7 @@ class VeritasZone {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.veritaszone_sovereignty(this.__wbg_ptr);
+            const ret = wasm.zone_sovereignty(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -260,7 +521,7 @@ class VeritasZone {
      * @returns {Uint8Array}
      */
     to_bytes() {
-        const ret = wasm.veritaszone_to_bytes(this.__wbg_ptr);
+        const ret = wasm.zone_to_bytes(this.__wbg_ptr);
         var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
@@ -270,15 +531,15 @@ class VeritasZone {
      * @returns {any}
      */
     to_json() {
-        const ret = wasm.veritaszone_to_json(this.__wbg_ptr);
+        const ret = wasm.zone_to_json(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return takeFromExternrefTable0(ret[0]);
     }
 }
-if (Symbol.dispose) VeritasZone.prototype[Symbol.dispose] = VeritasZone.prototype.free;
-exports.VeritasZone = VeritasZone;
+if (Symbol.dispose) Zone.prototype[Symbol.dispose] = Zone.prototype.free;
+exports.Zone = Zone;
 
 /**
  * Decode stored certificate bytes to a JS object.
@@ -297,9 +558,9 @@ function decode_certificate(bytes) {
 exports.decode_certificate = decode_certificate;
 
 /**
- * Decode stored zone bytes to a VeritasZone object.
+ * Decode stored zone bytes to a Zone object.
  * @param {Uint8Array} bytes
- * @returns {VeritasZone}
+ * @returns {Zone}
  */
 function decode_zone(bytes) {
     const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
@@ -308,7 +569,7 @@ function decode_zone(bytes) {
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
-    return VeritasZone.__wrap(ret[0]);
+    return Zone.__wrap(ret[0]);
 }
 exports.decode_zone = decode_zone;
 
@@ -371,61 +632,65 @@ exports.verify_spaces_message = verify_spaces_message;
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg_Error_8c4e43fe74559d73: function(arg0, arg1) {
+        __wbg_Error_83742b46f01ce22d: function(arg0, arg1) {
             const ret = Error(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_Number_04624de7d0e8332d: function(arg0) {
+        __wbg_Number_a5a435bd7bbec835: function(arg0) {
             const ret = Number(arg0);
             return ret;
         },
-        __wbg_String_8f0eb39a4a4c2f66: function(arg0, arg1) {
+        __wbg_String_8564e559799eccda: function(arg0, arg1) {
             const ret = String(arg1);
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
             const len1 = WASM_VECTOR_LEN;
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg___wbindgen_boolean_get_bbbb1c18aa2f5e25: function(arg0) {
+        __wbg___wbindgen_boolean_get_c0f3f60bac5a78d1: function(arg0) {
             const v = arg0;
             const ret = typeof(v) === 'boolean' ? v : undefined;
             return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
         },
-        __wbg___wbindgen_debug_string_0bc8482c6e3508ae: function(arg0, arg1) {
+        __wbg___wbindgen_debug_string_5398f5bb970e0daa: function(arg0, arg1) {
             const ret = debugString(arg1);
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
             const len1 = WASM_VECTOR_LEN;
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg___wbindgen_in_47fa6863be6f2f25: function(arg0, arg1) {
+        __wbg___wbindgen_in_41dbb8413020e076: function(arg0, arg1) {
             const ret = arg0 in arg1;
             return ret;
         },
-        __wbg___wbindgen_is_function_0095a73b8b156f76: function(arg0) {
+        __wbg___wbindgen_is_function_3c846841762788c1: function(arg0) {
             const ret = typeof(arg0) === 'function';
             return ret;
         },
-        __wbg___wbindgen_is_object_5ae8e5880f2c1fbd: function(arg0) {
+        __wbg___wbindgen_is_null_0b605fc6b167c56f: function(arg0) {
+            const ret = arg0 === null;
+            return ret;
+        },
+        __wbg___wbindgen_is_object_781bc9f159099513: function(arg0) {
             const val = arg0;
             const ret = typeof(val) === 'object' && val !== null;
             return ret;
         },
-        __wbg___wbindgen_is_undefined_9e4d92534c42d778: function(arg0) {
+        __wbg___wbindgen_is_undefined_52709e72fb9f179c: function(arg0) {
             const ret = arg0 === undefined;
             return ret;
         },
-        __wbg___wbindgen_jsval_loose_eq_9dd77d8cd6671811: function(arg0, arg1) {
+        __wbg___wbindgen_jsval_loose_eq_5bcc3bed3c69e72b: function(arg0, arg1) {
             const ret = arg0 == arg1;
             return ret;
         },
-        __wbg___wbindgen_number_get_8ff4255516ccad3e: function(arg0, arg1) {
+        __wbg___wbindgen_number_get_34bb9d9dcfa21373: function(arg0, arg1) {
             const obj = arg1;
             const ret = typeof(obj) === 'number' ? obj : undefined;
             getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
         },
-        __wbg___wbindgen_string_get_72fb696202c56729: function(arg0, arg1) {
+        __wbg___wbindgen_string_get_395e606bd0ee4427: function(arg0, arg1) {
             const obj = arg1;
             const ret = typeof(obj) === 'string' ? obj : undefined;
             var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -433,30 +698,46 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg___wbindgen_throw_be289d5034ed271b: function(arg0, arg1) {
+        __wbg___wbindgen_throw_6ddd609b62940d55: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_call_389efe28435a9388: function() { return handleError(function (arg0, arg1) {
+        __wbg_call_e133b57c9155d22c: function() { return handleError(function (arg0, arg1) {
             const ret = arg0.call(arg1);
             return ret;
         }, arguments); },
-        __wbg_done_57b39ecd9addfe81: function(arg0) {
+        __wbg_done_08ce71ee07e3bd17: function(arg0) {
             const ret = arg0.done;
             return ret;
         },
-        __wbg_get_9b94d73e6221f75c: function(arg0, arg1) {
-            const ret = arg0[arg1 >>> 0];
+        __wbg_entries_e8a20ff8c9757101: function(arg0) {
+            const ret = Object.entries(arg0);
             return ret;
         },
-        __wbg_get_b3ed3ad4be2bc8ac: function() { return handleError(function (arg0, arg1) {
+        __wbg_from_4bdf88943703fd48: function(arg0) {
+            const ret = Array.from(arg0);
+            return ret;
+        },
+        __wbg_get_326e41e095fb2575: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(arg0, arg1);
+            return ret;
+        }, arguments); },
+        __wbg_get_3ef1eba1850ade27: function() { return handleError(function (arg0, arg1) {
             const ret = Reflect.get(arg0, arg1);
             return ret;
         }, arguments); },
-        __wbg_get_with_ref_key_1dc361bd10053bfe: function(arg0, arg1) {
+        __wbg_get_a8ee5c45dabc1b3b: function(arg0, arg1) {
+            const ret = arg0[arg1 >>> 0];
+            return ret;
+        },
+        __wbg_get_unchecked_329cfe50afab7352: function(arg0, arg1) {
+            const ret = arg0[arg1 >>> 0];
+            return ret;
+        },
+        __wbg_get_with_ref_key_6412cf3094599694: function(arg0, arg1) {
             const ret = arg0[arg1];
             return ret;
         },
-        __wbg_instanceof_ArrayBuffer_c367199e2fa2aa04: function(arg0) {
+        __wbg_instanceof_ArrayBuffer_101e2bf31071a9f6: function(arg0) {
             let result;
             try {
                 result = arg0 instanceof ArrayBuffer;
@@ -466,7 +747,7 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
-        __wbg_instanceof_Uint8Array_9b9075935c74707c: function(arg0) {
+        __wbg_instanceof_Uint8Array_740438561a5b956d: function(arg0) {
             let result;
             try {
                 result = arg0 instanceof Uint8Array;
@@ -476,51 +757,51 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
-        __wbg_isArray_d314bb98fcf08331: function(arg0) {
+        __wbg_isArray_33b91feb269ff46e: function(arg0) {
             const ret = Array.isArray(arg0);
             return ret;
         },
-        __wbg_isSafeInteger_bfbc7332a9768d2a: function(arg0) {
+        __wbg_isSafeInteger_ecd6a7f9c3e053cd: function(arg0) {
             const ret = Number.isSafeInteger(arg0);
             return ret;
         },
-        __wbg_iterator_6ff6560ca1568e55: function() {
+        __wbg_iterator_d8f549ec8fb061b1: function() {
             const ret = Symbol.iterator;
             return ret;
         },
-        __wbg_length_32ed9a279acd054c: function(arg0) {
+        __wbg_length_b3416cf66a5452c8: function(arg0) {
             const ret = arg0.length;
             return ret;
         },
-        __wbg_length_35a7bace40f36eac: function(arg0) {
+        __wbg_length_ea16607d7b61445b: function(arg0) {
             const ret = arg0.length;
             return ret;
         },
-        __wbg_new_dd2b680c8bf6ae29: function(arg0) {
+        __wbg_new_5f486cdf45a04d78: function(arg0) {
             const ret = new Uint8Array(arg0);
             return ret;
         },
-        __wbg_next_3482f54c49e8af19: function() { return handleError(function (arg0) {
+        __wbg_next_11b99ee6237339e3: function() { return handleError(function (arg0) {
             const ret = arg0.next();
             return ret;
         }, arguments); },
-        __wbg_next_418f80d8f5303233: function(arg0) {
+        __wbg_next_e01a967809d1aa68: function(arg0) {
             const ret = arg0.next;
             return ret;
         },
-        __wbg_parse_708461a1feddfb38: function() { return handleError(function (arg0, arg1) {
+        __wbg_parse_e9eddd2a82c706eb: function() { return handleError(function (arg0, arg1) {
             const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
             return ret;
         }, arguments); },
-        __wbg_prototypesetcall_bdcdcc5842e4d77d: function(arg0, arg1, arg2) {
+        __wbg_prototypesetcall_d62e5099504357e6: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
         },
-        __wbg_value_0546255b415e96c1: function(arg0) {
+        __wbg_value_21fc78aab0322612: function(arg0) {
             const ret = arg0.value;
             return ret;
         },
-        __wbg_veritaszone_new: function(arg0) {
-            const ret = VeritasZone.__wrap(arg0);
+        __wbg_zone_new: function(arg0) {
+            const ret = Zone.__wrap(arg0);
             return ret;
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
@@ -544,18 +825,30 @@ function __wbg_get_imports() {
     };
 }
 
+const MessageFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_message_free(ptr >>> 0, 1));
+const MessageBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_messagebuilder_free(ptr >>> 0, 1));
+const OffchainDataFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_offchaindata_free(ptr >>> 0, 1));
 const QueryContextFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_querycontext_free(ptr >>> 0, 1));
+const RecordSetFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_recordset_free(ptr >>> 0, 1));
 const VerifiedMessageFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_verifiedmessage_free(ptr >>> 0, 1));
 const VeritasFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_veritas_free(ptr >>> 0, 1));
-const VeritasZoneFinalization = (typeof FinalizationRegistry === 'undefined')
+const ZoneFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_veritaszone_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_zone_free(ptr >>> 0, 1));
 
 function addToExternrefTable0(obj) {
     const idx = wasm.__externref_table_alloc();
@@ -758,5 +1051,5 @@ let WASM_VECTOR_LEN = 0;
 const wasmPath = `${__dirname}/libveritas_bg.wasm`;
 const wasmBytes = require('fs').readFileSync(wasmPath);
 const wasmModule = new WebAssembly.Module(wasmBytes);
-const wasm = new WebAssembly.Instance(wasmModule, __wbg_get_imports()).exports;
+let wasm = new WebAssembly.Instance(wasmModule, __wbg_get_imports()).exports;
 wasm.__wbindgen_start();

package/package.json

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