@spacesprotocol/libveritas 0.0.0-dev.20260306225014 → 0.0.0-dev.20260317233723

package/libveritas.d.ts

@@ -16,13 +16,13 @@ export class Message {
      */
     to_bytes(): Uint8Array;
     /**
-     * Update offchain data on this message.
+     * Update records on this message.
      *
      * Accepts a JS array of data update entries:
      * ```js
      * msg.update([
-     *   { name: "alice@bitcoin", offchainData: Uint8Array },
-     *   { name: "@bitcoin", delegateOffchainData: Uint8Array }
+     *   { name: "alice@bitcoin", records: Uint8Array },
+     *   { name: "@bitcoin", delegateRecords: Uint8Array }
      * ])
      * ```
      *
@@ -54,8 +54,8 @@ export class MessageBuilder {
      *
      * ```js
      * let builder = new MessageBuilder([
-     *   { name: "@bitcoin", offchainData: Uint8Array, cert: Uint8Array },
-     *   { name: "alice@bitcoin", offchainData: Uint8Array, cert: Uint8Array }
+     *   { name: "@bitcoin", records: Uint8Array, cert: Uint8Array },
+     *   { name: "alice@bitcoin", records: Uint8Array, cert: Uint8Array }
      * ])
      * ```
      */
@@ -63,16 +63,20 @@ export class MessageBuilder {
 }
 
 /**
- * Helpers for constructing OffchainData.
+ * Helpers for constructing OffchainRecords (signed record sets).
+ *
+ * ```js
+ * const rs = RecordSet.pack([Record.seq(0), Record.txt("btc", "bc1qtest")]);
+ * const sig = await wallet.signSchnorr(rs.signingId());
+ * const bytes = OffchainRecords.from(rs, sig);
+ * ```
  */
-export class OffchainData {
+export class OffchainRecords {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
     /**
-     * Create borsh-encoded OffchainData from a RecordSet and a 64-byte Schnorr signature.
-     *
-     * Consumes the RecordSet.
+     * Create borsh-encoded OffchainRecords from a RecordSet and 64-byte signature.
      */
     static from(record_set: RecordSet, signature: Uint8Array): Uint8Array;
 }
@@ -93,25 +97,63 @@ export class QueryContext {
 }
 
 /**
- * Serialized records ready to be signed.
+ * Record constructors for building a RecordSet.
  *
  * ```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);
+ * const rs = RecordSet.pack([
+ *     Record.txt("btc", "bc1qtest"),
+ *     Record.blob("avatar", pngBytes),
+ *     Record.unknown(0x10, raw),
+ * ]);
+ * ```
+ */
+export class Record {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static blob(key: string, value: Uint8Array): any;
+    static seq(version: bigint): any;
+    static txt(key: string, value: string): any;
+    static unknown(rtype: number, rdata: Uint8Array): any;
+}
+
+/**
+ * SIP-7 record set — wire-format encoded records.
+ *
+ * ```js
+ * // Pack from records
+ * const rs = RecordSet.pack([Record.txt("btc", "bc1qtest")]);
+ * const wire = rs.toBytes();
+ *
+ * // Load from wire bytes
+ * const rs = new RecordSet(wire);
+ * for (const r of rs.unpack()) { ... }
  * ```
  */
 export class RecordSet {
     free(): void;
     [Symbol.dispose](): void;
+    isEmpty(): boolean;
+    /**
+     * Wrap raw wire bytes (lazy — no parsing until unpack).
+     */
+    constructor(data: Uint8Array);
+    /**
+     * Pack records into wire format.
+     */
+    static pack(records: any): RecordSet;
+    /**
+     * The 32-byte signing hash (Spaces signed-message prefix + SHA256).
+     */
+    signingId(): Uint8Array;
     /**
-     * The 32-byte hash to sign.
+     * Raw wire bytes.
      */
-    id(): Uint8Array;
+    toBytes(): Uint8Array;
     /**
-     * Create a record set from a sequence number and a JS object of key-value pairs.
+     * Parse all records.
      */
-    constructor(seq: number, records: any);
+    unpack(): any;
 }
 
 /**
@@ -163,6 +205,7 @@ export class Zone {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
+    alias(): string | undefined;
     anchor(): number;
     handle(): string;
     is_better_than(other: Zone): boolean;

package/libveritas.js

@@ -47,13 +47,13 @@ class Message {
         return v1;
     }
     /**
-     * Update offchain data on this message.
+     * Update records on this message.
      *
      * Accepts a JS array of data update entries:
      * ```js
      * msg.update([
-     *   { name: "alice@bitcoin", offchainData: Uint8Array },
-     *   { name: "@bitcoin", delegateOffchainData: Uint8Array }
+     *   { name: "alice@bitcoin", records: Uint8Array },
+     *   { name: "@bitcoin", delegateRecords: Uint8Array }
      * ])
      * ```
      *
@@ -118,8 +118,8 @@ class MessageBuilder {
      *
      * ```js
      * let builder = new MessageBuilder([
-     *   { name: "@bitcoin", offchainData: Uint8Array, cert: Uint8Array },
-     *   { name: "alice@bitcoin", offchainData: Uint8Array, cert: Uint8Array }
+     *   { name: "@bitcoin", records: Uint8Array, cert: Uint8Array },
+     *   { name: "alice@bitcoin", records: Uint8Array, cert: Uint8Array }
      * ])
      * ```
      * @param {any} requests
@@ -138,23 +138,27 @@ if (Symbol.dispose) MessageBuilder.prototype[Symbol.dispose] = MessageBuilder.pr
 exports.MessageBuilder = MessageBuilder;
 
 /**
- * Helpers for constructing OffchainData.
+ * Helpers for constructing OffchainRecords (signed record sets).
+ *
+ * ```js
+ * const rs = RecordSet.pack([Record.seq(0), Record.txt("btc", "bc1qtest")]);
+ * const sig = await wallet.signSchnorr(rs.signingId());
+ * const bytes = OffchainRecords.from(rs, sig);
+ * ```
  */
-class OffchainData {
+class OffchainRecords {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        OffchainDataFinalization.unregister(this);
+        OffchainRecordsFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_offchaindata_free(ptr, 0);
+        wasm.__wbg_offchainrecords_free(ptr, 0);
     }
     /**
-     * Create borsh-encoded OffchainData from a RecordSet and a 64-byte Schnorr signature.
-     *
-     * Consumes the RecordSet.
+     * Create borsh-encoded OffchainRecords from a RecordSet and 64-byte signature.
      * @param {RecordSet} record_set
      * @param {Uint8Array} signature
      * @returns {Uint8Array}
@@ -163,7 +167,7 @@ class OffchainData {
         _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);
+        const ret = wasm.offchainrecords_from(record_set.__wbg_ptr, ptr0, len0);
         if (ret[3]) {
             throw takeFromExternrefTable0(ret[2]);
         }
@@ -172,8 +176,8 @@ class OffchainData {
         return v2;
     }
 }
-if (Symbol.dispose) OffchainData.prototype[Symbol.dispose] = OffchainData.prototype.free;
-exports.OffchainData = OffchainData;
+if (Symbol.dispose) OffchainRecords.prototype[Symbol.dispose] = OffchainRecords.prototype.free;
+exports.OffchainRecords = OffchainRecords;
 
 class QueryContext {
     __destroy_into_raw() {
@@ -222,15 +226,97 @@ if (Symbol.dispose) QueryContext.prototype[Symbol.dispose] = QueryContext.protot
 exports.QueryContext = QueryContext;
 
 /**
- * Serialized records ready to be signed.
+ * Record constructors for building a RecordSet.
  *
  * ```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);
+ * const rs = RecordSet.pack([
+ *     Record.txt("btc", "bc1qtest"),
+ *     Record.blob("avatar", pngBytes),
+ *     Record.unknown(0x10, raw),
+ * ]);
+ * ```
+ */
+class Record {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RecordFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_record_free(ptr, 0);
+    }
+    /**
+     * @param {string} key
+     * @param {Uint8Array} value
+     * @returns {any}
+     */
+    static blob(key, value) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(value, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.record_blob(ptr0, len0, ptr1, len1);
+        return ret;
+    }
+    /**
+     * @param {bigint} version
+     * @returns {any}
+     */
+    static seq(version) {
+        const ret = wasm.record_seq(version);
+        return ret;
+    }
+    /**
+     * @param {string} key
+     * @param {string} value
+     * @returns {any}
+     */
+    static txt(key, value) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.record_txt(ptr0, len0, ptr1, len1);
+        return ret;
+    }
+    /**
+     * @param {number} rtype
+     * @param {Uint8Array} rdata
+     * @returns {any}
+     */
+    static unknown(rtype, rdata) {
+        const ptr0 = passArray8ToWasm0(rdata, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.record_unknown(rtype, ptr0, len0);
+        return ret;
+    }
+}
+if (Symbol.dispose) Record.prototype[Symbol.dispose] = Record.prototype.free;
+exports.Record = Record;
+
+/**
+ * SIP-7 record set — wire-format encoded records.
+ *
+ * ```js
+ * // Pack from records
+ * const rs = RecordSet.pack([Record.txt("btc", "bc1qtest")]);
+ * const wire = rs.toBytes();
+ *
+ * // Load from wire bytes
+ * const rs = new RecordSet(wire);
+ * for (const r of rs.unpack()) { ... }
  * ```
  */
 class RecordSet {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(RecordSet.prototype);
+        obj.__wbg_ptr = ptr;
+        RecordSetFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -242,31 +328,66 @@ class RecordSet {
         wasm.__wbg_recordset_free(ptr, 0);
     }
     /**
-     * The 32-byte hash to sign.
-     * @returns {Uint8Array}
+     * @returns {boolean}
      */
-    id() {
-        const ret = wasm.recordset_id(this.__wbg_ptr);
-        if (ret[3]) {
-            throw takeFromExternrefTable0(ret[2]);
+    isEmpty() {
+        const ret = wasm.recordset_isEmpty(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Wrap raw wire bytes (lazy — no parsing until unpack).
+     * @param {Uint8Array} data
+     */
+    constructor(data) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.recordset_new(ptr0, len0);
+        this.__wbg_ptr = ret >>> 0;
+        RecordSetFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Pack records into wire format.
+     * @param {any} records
+     * @returns {RecordSet}
+     */
+    static pack(records) {
+        const ret = wasm.recordset_pack(records);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
+        return RecordSet.__wrap(ret[0]);
+    }
+    /**
+     * The 32-byte signing hash (Spaces signed-message prefix + SHA256).
+     * @returns {Uint8Array}
+     */
+    signingId() {
+        const ret = wasm.recordset_signingId(this.__wbg_ptr);
         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
+     * Raw wire bytes.
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        const ret = wasm.recordset_toBytes(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Parse all records.
+     * @returns {any}
      */
-    constructor(seq, records) {
-        const ret = wasm.recordset_new(seq, records);
+    unpack() {
+        const ret = wasm.recordset_unpack(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        this.__wbg_ptr = ret[0] >>> 0;
-        RecordSetFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+        return takeFromExternrefTable0(ret[0]);
     }
 }
 if (Symbol.dispose) RecordSet.prototype[Symbol.dispose] = RecordSet.prototype.free;
@@ -467,6 +588,18 @@ class Zone {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_zone_free(ptr, 0);
     }
+    /**
+     * @returns {string | undefined}
+     */
+    alias() {
+        const ret = wasm.zone_alias(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
     /**
      * @returns {number}
      */
@@ -708,10 +841,6 @@ function __wbg_get_imports() {
             const ret = arg0.done;
             return ret;
         },
-        __wbg_entries_e8a20ff8c9757101: function(arg0) {
-            const ret = Object.entries(arg0);
-            return ret;
-        },
         __wbg_from_4bdf88943703fd48: function(arg0) {
             const ret = Array.from(arg0);
             return ret;
@@ -780,6 +909,18 @@ function __wbg_get_imports() {
             const ret = new Uint8Array(arg0);
             return ret;
         },
+        __wbg_new_a70fbab9066b301f: function() {
+            const ret = new Array();
+            return ret;
+        },
+        __wbg_new_ab79df5bd7c26067: function() {
+            const ret = new Object();
+            return ret;
+        },
+        __wbg_new_from_slice_22da9388ac046e50: function(arg0, arg1) {
+            const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+            return ret;
+        },
         __wbg_next_11b99ee6237339e3: function() { return handleError(function (arg0) {
             const ret = arg0.next();
             return ret;
@@ -795,6 +936,14 @@ function __wbg_get_imports() {
         __wbg_prototypesetcall_d62e5099504357e6: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
         },
+        __wbg_push_e87b0e732085a946: function(arg0, arg1) {
+            const ret = arg0.push(arg1);
+            return ret;
+        },
+        __wbg_set_7eaa4f96924fd6b3: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.set(arg0, arg1, arg2);
+            return ret;
+        }, arguments); },
         __wbg_value_21fc78aab0322612: function(arg0) {
             const ret = arg0.value;
             return ret;
@@ -803,11 +952,21 @@ function __wbg_get_imports() {
             const ret = Zone.__wrap(arg0);
             return ret;
         },
-        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000001: function(arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
+            return ret;
+        },
+        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
         },
+        __wbindgen_cast_0000000000000003: function(arg0) {
+            // Cast intrinsic for `U64 -> Externref`.
+            const ret = BigInt.asUintN(64, arg0);
+            return ret;
+        },
         __wbindgen_init_externref_table: function() {
             const table = wasm.__wbindgen_externrefs;
             const offset = table.grow(4);
@@ -830,12 +989,15 @@ const MessageFinalization = (typeof FinalizationRegistry === 'undefined')
 const MessageBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_messagebuilder_free(ptr >>> 0, 1));
-const OffchainDataFinalization = (typeof FinalizationRegistry === 'undefined')
+const OffchainRecordsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_offchaindata_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_offchainrecords_free(ptr >>> 0, 1));
 const QueryContextFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_querycontext_free(ptr >>> 0, 1));
+const RecordFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_record_free(ptr >>> 0, 1));
 const RecordSetFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_recordset_free(ptr >>> 0, 1));

package/package.json

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