@msgboard/sdk 0.0.28

package/README.md

@@ -0,0 +1,314 @@
+# @msgboard/sdk
+
+Distribute ephemeral messages across EVM networks using proof of work as the gate — no gas, no token, no account. You mint your own proof-of-work "stamp" for each message; that stamp is what keeps the board spam-resistant.
+
+## Install
+
+```sh
+npm i --save @msgboard/sdk
+```
+
+## Quickstart
+
+You need an RPC endpoint whose node runs the `msgboard_` module. Public PulseChain/Ethereum RPCs do **not** run it yet; valve.city does (for example `https://one.valve.city/rpc/vk_demo/evm/369`). You can also run your own node with the module.
+
+### with viem
+
+```ts
+import * as msgboard from '@msgboard/sdk'
+import { createPublicClient, http } from 'viem'
+import { pulsechain } from 'viem/chains'
+
+const client = createPublicClient({
+  chain: pulsechain,
+  transport: http('https://one.valve.city/rpc/vk_demo/evm/369'),
+})
+const board = new msgboard.MsgBoardClient(client)
+
+// do the work for your category and data
+const work = await board.doPoW('gasmoneyplease', 'hello board')
+// submit the valid message
+const hash = await board.addMessage(work.message)
+```
+
+### with ethers
+
+```ts
+import * as msgboard from '@msgboard/sdk'
+import { providers } from 'ethers'
+
+const provider = new providers.JsonRpcProvider('https://one.valve.city/rpc/vk_demo/evm/369')
+const board = new msgboard.MsgBoardClient(msgboard.wrapLegacySend(provider))
+
+const work = await board.doPoW('gasmoneyplease', 'hello board')
+const hash = await board.addMessage(work.message)
+```
+
+### read the board
+
+```ts
+const status = await board.status()       // enabled, counts, difficulty factors
+const categories = await board.categories()
+const content = await board.content()      // messages grouped by category
+```
+
+## Finding a node
+
+A node must run the `msgboard_` module to serve these methods. If `status()` reports `enabled: false`, or a call returns JSON-RPC error `-32601` (method not found), the node does not have the module — point at one that does. See the live status badge on https://msgboard.xyz for working endpoints.
+
+## Proof of work and difficulty
+
+Submission is gated by proof of work, not a fee. Difficulty scales with message size:
+
+```ts
+((2n ** 24n + BigInt(dataLen) * 10_000n) * workMultiplier) / workDivisor
+```
+
+`dataLen` is measured in **bytes** (not hex characters); each byte adds 10,000 to the difficulty under the default factors, which rewards compact message packing. Compute the difficulty for a payload with:
+
+```ts
+board.getDifficulty('0x...') // bigint
+```
+
+`workMultiplier` and `workDivisor` come from `status()` and are applied automatically by `doPoW`.
+
+## Categories
+
+A category is a 32-byte hash. Pass a string and the client hashes it for you (`categoryHash`); pass hex and it is used as-is. The demo board uses the `gasmoneyplease` category.
+
+## Ephemerality
+
+Messages are short-lived: the board retains roughly the last 120 blocks of messages, so the board is a live signal, not durable storage.
+
+## Keeping work off the UI thread
+
+`doPoW` is a busy loop; JavaScript blocks while it runs. In a browser, run it in a Web Worker so the interface stays responsive. The client yields periodically (`breakInterval`) to let block updates resolve, but the heavy hashing still occupies the thread it runs on.
+
+<!-- GENERATED:OPENRPC:START -->
+
+## JSON-RPC methods
+
+### msgboard_status
+
+Board status and the difficulty factors required for valid messages.
+
+| Parameter | Type | Required |
+| --- | --- | --- |
+| _(none)_ | | |
+
+**Returns:** `Status`
+
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "msgboard_status",
+  "params": []
+}
+```
+
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "result": {
+    "enabled": true,
+    "count": "0x0",
+    "size": "0x0",
+    "workMultiplier": "0x2710",
+    "workDivisor": "0xf4240"
+  }
+}
+```
+
+### msgboard_categories
+
+The list of 32-byte category hashes currently present on the board.
+
+| Parameter | Type | Required |
+| --- | --- | --- |
+| _(none)_ | | |
+
+**Returns:** `Categories`
+
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "msgboard_categories",
+  "params": []
+}
+```
+
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "result": [
+    "0x6761736d6f6e6579706c65617365000000000000000000000000000000000000"
+  ]
+}
+```
+
+### msgboard_content
+
+All messages on the board, grouped by category hash. Optionally filtered.
+
+| Parameter | Type | Required |
+| --- | --- | --- |
+| `filter` | `ContentFilter` | no |
+
+**Returns:** `Content`
+
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "msgboard_content",
+  "params": [
+    {}
+  ]
+}
+```
+
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "result": {}
+}
+```
+
+### msgboard_addMessage
+
+Submit a proof-of-work message (RLP-encoded) to the board.
+
+| Parameter | Type | Required |
+| --- | --- | --- |
+| `rlp` | `Hex` | yes |
+
+**Returns:** `Hex`
+
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "msgboard_addMessage",
+  "params": [
+    "0xf800"
+  ]
+}
+```
+
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "result": "0x0d1e2f00000000000000000000000000000000000000000000000000c46845f9"
+}
+```
+
+### msgboard_getMessage
+
+Fetch a single message by its hash.
+
+| Parameter | Type | Required |
+| --- | --- | --- |
+| `hash` | `Hex` | yes |
+
+**Returns:** `RPCMessage`
+
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "msgboard_getMessage",
+  "params": [
+    "0x0000000000000000000000000000000000000000000000000000000000000000"
+  ]
+}
+```
+
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "result": {
+    "version": "0x1",
+    "blockHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+    "blockNumber": "0x0",
+    "category": "0x0000000000000000000000000000000000000000000000000000000000000000",
+    "data": "0x0000000000000000000000000000000000000000000000000000000000000000",
+    "nonce": "0x0",
+    "hash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+    "workMultiplier": "0x0",
+    "workDivisor": "0x0"
+  }
+}
+```
+
+## Schemas
+
+### Hex
+
+String matching `^0x[0-9a-fA-F]*$`.
+
+### Status
+
+| Field | Type | Description |
+| --- | --- | --- |
+| `enabled` (required) | `boolean` | Whether the module is enabled on this node. |
+| `count` (required) | `Hex` | Overall count of messages stored on the board. |
+| `size` (required) | `Hex` | Overall size of messages stored on the board. |
+| `workMultiplier` (required) | `Hex` | Factor that increases required work. |
+| `workDivisor` (required) | `Hex` | Factor that decreases required work. |
+
+### Categories
+
+Array of `Hex`.
+
+### ContentFilter
+
+| Field | Type | Description |
+| --- | --- | --- |
+| `category` | `Hex` | Restrict to one category hash. |
+| `fromBlock` | `Hex` | Lower block bound (hex quantity). |
+| `toBlock` | `Hex` | Upper block bound (hex quantity). |
+
+### RPCMessage
+
+| Field | Type | Description |
+| --- | --- | --- |
+| `version` (required) | `Hex` | Message/encoding version. |
+| `blockHash` (required) | `Hex` | Hash of the block the message is rooted to. |
+| `blockNumber` (required) | `Hex` | Number of the block the message is rooted to. |
+| `category` (required) | `Hex` | 32-byte category hash. |
+| `data` (required) | `Hex` | Arbitrary message data. |
+| `nonce` (required) | `Hex` | Nonce discovered through proof of work. |
+| `hash` (required) | `Hex` | The message hash. |
+| `workMultiplier` (required) | `Hex` | Work multiplier in force when posted. |
+| `workDivisor` (required) | `Hex` | Work divisor in force when posted. |
+
+### Content
+
+Messages grouped by category hash.
+
+Object whose values are `RPCMessage[]`.
+
+<!-- GENERATED:OPENRPC:END -->
+
+## Client methods (not JSON-RPC)
+
+These run in the client, not on the node, so they are not in the OpenRPC spec:
+
+- `doPoW(category, data, limit?)` — grind a valid proof-of-work message. Returns `{ message, stats }`.
+- `getDifficulty(data)` — the difficulty for a given payload, as a `bigint`.
+- Utilities: `categoryHash`, `checkWork`, `difficulty`, `encodeData`, `toRLP`, `fromRLP`, `fromRPCMessage`, `toRPCMessage`, `wrapLegacySend`.
+
+## Machine-readable spec
+
+The JSON-RPC surface is published as an OpenRPC document at `openrpc.json` in this package. Point the OpenRPC Playground or a code generator at it.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,96 @@
+import { type Hex } from 'viem';
+import type { Config, Content, ContentFilter, DifficultyFactors, Logger, MessageSeed, Provider, RPCMessage, Status, WorkResult, WorkStats } from '@msgboard/core';
+export * from '@msgboard/core';
+/**
+ * MsgboardClient can be used for interacting with the msgboard API
+ * and performing necessary work to find valid messages.
+ */
+export declare class MsgBoardClient {
+    protected provider: Provider;
+    private _difficultyFactors;
+    log: Logger;
+    breakInterval: bigint;
+    cancelled: boolean;
+    progressHandler: (stats: WorkStats) => void;
+    version: number;
+    constructor(provider: Provider, config?: Config);
+    get difficultyFactors(): DifficultyFactors;
+    set difficultyFactors(factors: DifficultyFactors);
+    /** Can be called to cancel a doPoW operation in progress. */
+    cancel(): void;
+    /**
+     * Starts a busy work loop, in search of a nonce to create a valid pow message
+     * with the given inputs and configured difficulty.
+     * @param category The 32-byte hash or string to be used as the message category
+     * @param data the data bytes or string to embed in the message
+     * @param limit an optional limit to the number of iterations that will be attempted
+     * @returns a promise that will resolve with a valid work object, containing a pow
+     * message that can be submitted to the API and a stats object about the work that was done
+     */
+    doPoW(category: Hex | string, data: Hex | string, limit?: bigint): Promise<WorkResult>;
+    /**
+     * Fetches the latest block from the RPC.
+     * @returns the block details
+     * @throws error responses from the RPC
+     */
+    lastestBlock(): Promise<{
+        hash: Hex;
+        number: Hex;
+    }>;
+    /**
+     * Submits a message to the board RPC.
+     * @param input the RLP encoded message to add
+     * @returns the message hash
+     * @throws error responses from the RPC
+     */
+    addMessage(input: Hex | MessageSeed): Promise<`0x${string}`>;
+    /**
+     * Fetches a message from the board RPC.
+     * @param category category to lookup message
+     * @param msgHash hash of the message to look up message on RPC
+     * @returns a message from the RPC
+     * @throws error responses from the RPC
+     */
+    getMessage(msgHash: Hex): Promise<RPCMessage>;
+    /**
+     * Fetches message categories from the board RPC.
+     * @returns the list category hashes available on the board
+     * @throws error responses from the RPC
+     */
+    categories(): Promise<`0x${string}`[]>;
+    /**
+     * Fetches all messages from the board RPC.
+     * @returns the board messages, grouped by category
+     * @throws error responses from the RPC
+     */
+    content(filter?: ContentFilter): Promise<Content>;
+    /**
+     * Fetches the status of the msgboard from the board RPC.
+     * @returns the status info of the msgboard
+     * @throws error responses from the RPC
+     */
+    status(): Promise<Status>;
+    /**
+     * Updates the difficulty factors for performing message work.
+     * @param workMultiplier the work multiplier increases difficulty
+     * @param workDivisor the work divisor decreases difficulty
+     */
+    setDifficultyFactors(workMultiplier: bigint, workDivisor: bigint): void;
+    /**
+     * Calculates the difficulty for a given message.
+     * @param data the data bytes or string to embed in the message
+     * @returns the difficulty
+     */
+    getDifficulty(data: Hex): bigint;
+    /**
+     * Calls the provider RPC directly
+     * @param method the method to call
+     * @param params the parameters to pass to the method
+     * @returns the response from the RPC
+     */
+    request<T, U extends unknown[]>(arg: {
+        method: string;
+        params: U;
+    }): Promise<T>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,GAAG,EAAwB,MAAM,MAAM,CAAA;AAErD,OAAO,KAAK,EACV,MAAM,EACN,OAAO,EACP,aAAa,EACb,iBAAiB,EACjB,MAAM,EAEN,WAAW,EACX,QAAQ,EACR,UAAU,EACV,MAAM,EACN,UAAU,EACV,SAAS,EACV,MAAM,gBAAgB,CAAA;AAGvB,cAAc,gBAAgB,CAAA;AAO9B;;;GAGG;AACH,qBAAa,cAAc;IAcvB,SAAS,CAAC,QAAQ,EAAE,QAAQ;IAb9B,OAAO,CAAC,kBAAkB,CAAmB;IAE7C,GAAG,EAAE,MAAM,CAAA;IAEX,aAAa,EAAE,MAAM,CAAA;IAErB,SAAS,EAAE,OAAO,CAAQ;IAE1B,eAAe,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAA;IAE3C,OAAO,EAAE,MAAM,CAAI;gBAGP,QAAQ,EAAE,QAAQ,EAC5B,MAAM,GAAE,MAAW;IAYrB,IAAI,iBAAiB,IAMU,iBAAiB,CAD/C;IACD,IAAI,iBAAiB,CAAC,OAAO,EAAE,iBAAiB,EAK/C;IAED,6DAA6D;IAC7D,MAAM;IAIN;;;;;;;;OAQG;IACG,KAAK,CAAC,QAAQ,EAAE,GAAG,GAAG,MAAM,EAAE,IAAI,EAAE,GAAG,GAAG,MAAM,EAAE,KAAK,SAAgB,GAAG,OAAO,CAAC,UAAU,CAAC;IA8EnG;;;;OAIG;IACG,YAAY;cACY,GAAG;gBAAU,GAAG;;IAM9C;;;;;OAKG;IACG,UAAU,CAAC,KAAK,EAAE,GAAG,GAAG,WAAW;IAKzC;;;;;;OAMG;IACG,UAAU,CAAC,OAAO,EAAE,GAAG;IAI7B;;;;OAIG;IACG,UAAU;IAIhB;;;;OAIG;IACG,OAAO,CAAC,MAAM,GAAE,aAAkB;IAIxC;;;;OAIG;IACG,MAAM;IAIZ;;;;OAIG;IACH,oBAAoB,CAAC,cAAc,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;IAGhE;;;;OAIG;IACH,aAAa,CAAC,IAAI,EAAE,GAAG;IAIvB;;;;;OAKG;IACG,OAAO,CAAC,CAAC,EAAE,CAAC,SAAS,OAAO,EAAE,EAAE,GAAG,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,CAAC,CAAA;KAAE,GAAG,OAAO,CAAC,CAAC,CAAC;CAItF"}

package/dist/index.js

@@ -0,0 +1,233 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsgBoardClient = void 0;
+const viem_1 = require("viem");
+const logger_js_1 = __importDefault(require("./logger.js"));
+const core_1 = require("@msgboard/core");
+__exportStar(require("@msgboard/core"), exports);
+const veryHighLimit = 100000000n;
+// eslint-disable-next-line
+const defaultLogger = (prefix, ...args) => (0, logger_js_1.default)(prefix, ...args);
+/**
+ * MsgboardClient can be used for interacting with the msgboard API
+ * and performing necessary work to find valid messages.
+ */
+class MsgBoardClient {
+    provider;
+    _difficultyFactors;
+    log;
+    breakInterval;
+    cancelled = false;
+    progressHandler;
+    version = 1;
+    constructor(provider, config = {}) {
+        this.provider = provider;
+        this._difficultyFactors = {
+            workMultiplier: 10000n,
+            workDivisor: 1000000n,
+            ...(config.difficultyFactors ?? {}),
+        };
+        this.log = config.logger || defaultLogger;
+        this.breakInterval = config.breakInterval || 10000n;
+        this.progressHandler = config.progress || (() => { });
+    }
+    get difficultyFactors() {
+        return {
+            workMultiplier: this._difficultyFactors.workMultiplier,
+            workDivisor: this._difficultyFactors.workDivisor,
+        };
+    }
+    set difficultyFactors(factors) {
+        this._difficultyFactors = {
+            ...this._difficultyFactors,
+            ...factors,
+        };
+    }
+    /** Can be called to cancel a doPoW operation in progress. */
+    cancel() {
+        this.cancelled = true;
+    }
+    /**
+     * Starts a busy work loop, in search of a nonce to create a valid pow message
+     * with the given inputs and configured difficulty.
+     * @param category The 32-byte hash or string to be used as the message category
+     * @param data the data bytes or string to embed in the message
+     * @param limit an optional limit to the number of iterations that will be attempted
+     * @returns a promise that will resolve with a valid work object, containing a pow
+     * message that can be submitted to the API and a stats object about the work that was done
+     */
+    async doPoW(category, data, limit = veryHighLimit) {
+        this.log('starting pow on message');
+        this.cancelled = false;
+        let killPoll = false;
+        const message = {
+            blockHash: viem_1.zeroHash,
+            blockNumber: 0n,
+            category: (0, core_1.categoryHash)(category),
+            data: (0, core_1.encodeData)(data),
+            hash: viem_1.zeroHash,
+            nonce: 0n,
+            version: this.version,
+            workMultiplier: this.difficultyFactors.workMultiplier,
+            workDivisor: this.difficultyFactors.workDivisor,
+        };
+        const dataLen = (0, viem_1.hexToBytes)(message.data).length;
+        const stats = {
+            difficulty: (0, core_1.difficulty)(this.difficultyFactors, dataLen),
+            duration: 0,
+            isValid: false,
+            iterations: 0n,
+        };
+        // if we want to support multiple pow searches,
+        // then we need to move this polling outside of this method
+        // otherwise get block will be fetching at a commenserate rate
+        // to the number of outstanding pow searches are currently running
+        const getBlock = async () => {
+            if (killPoll)
+                return;
+            const { hash, ...block } = await this.lastestBlock();
+            const number = BigInt(block.number);
+            if (!killPoll && (message.blockNumber === 0n || message.blockNumber !== number)) {
+                message.blockHash = hash;
+                message.blockNumber = number;
+                this.log('updated block info %o@%o', hash, number);
+            }
+            // queue next operation
+            setTimeout(() => {
+                getBlock().catch(logger_js_1.default);
+            }, 1_000);
+        };
+        // start the polling for block updates
+        await getBlock();
+        const { breakInterval } = this;
+        const start = Date.now();
+        this.progressHandler({ ...stats });
+        while (true) {
+            if (this.cancelled) {
+                killPoll = true;
+                return { message, stats };
+            }
+            message.nonce += 1n;
+            stats.duration = Date.now() - start;
+            stats.iterations += 1n;
+            const hash = (0, core_1.checkWork)(message, stats.difficulty);
+            if (hash) {
+                message.hash = hash;
+                stats.isValid = true;
+                killPoll = true;
+                return { message, stats };
+            }
+            if (stats.iterations >= limit) {
+                killPoll = true;
+                throw new Error('limit met');
+            }
+            if (breakInterval && message.nonce % breakInterval === 0n) {
+                this.progressHandler({ ...stats });
+                // pauses the PoW busy loop to allow the event loop to resolve the block updates
+                await new Promise((resolve) => {
+                    setTimeout(resolve, 10);
+                });
+            }
+        }
+    }
+    /**
+     * Fetches the latest block from the RPC.
+     * @returns the block details
+     * @throws error responses from the RPC
+     */
+    async lastestBlock() {
+        return this.request({
+            method: 'eth_getBlockByNumber',
+            params: ['latest', false],
+        });
+    }
+    /**
+     * Submits a message to the board RPC.
+     * @param input the RLP encoded message to add
+     * @returns the message hash
+     * @throws error responses from the RPC
+     */
+    async addMessage(input) {
+        const rlp = typeof input !== 'string' ? (0, core_1.toRLP)(input) : input;
+        return this.request({ method: 'msgboard_addMessage', params: [rlp] });
+    }
+    /**
+     * Fetches a message from the board RPC.
+     * @param category category to lookup message
+     * @param msgHash hash of the message to look up message on RPC
+     * @returns a message from the RPC
+     * @throws error responses from the RPC
+     */
+    async getMessage(msgHash) {
+        return this.request({ method: 'msgboard_getMessage', params: [msgHash] });
+    }
+    /**
+     * Fetches message categories from the board RPC.
+     * @returns the list category hashes available on the board
+     * @throws error responses from the RPC
+     */
+    async categories() {
+        return this.request({ method: 'msgboard_categories', params: [] });
+    }
+    /**
+     * Fetches all messages from the board RPC.
+     * @returns the board messages, grouped by category
+     * @throws error responses from the RPC
+     */
+    async content(filter = {}) {
+        return this.request({ method: 'msgboard_content', params: [filter] });
+    }
+    /**
+     * Fetches the status of the msgboard from the board RPC.
+     * @returns the status info of the msgboard
+     * @throws error responses from the RPC
+     */
+    async status() {
+        return this.request({ method: 'msgboard_status', params: [] });
+    }
+    /**
+     * Updates the difficulty factors for performing message work.
+     * @param workMultiplier the work multiplier increases difficulty
+     * @param workDivisor the work divisor decreases difficulty
+     */
+    setDifficultyFactors(workMultiplier, workDivisor) {
+        this.difficultyFactors = { workMultiplier, workDivisor };
+    }
+    /**
+     * Calculates the difficulty for a given message.
+     * @param data the data bytes or string to embed in the message
+     * @returns the difficulty
+     */
+    getDifficulty(data) {
+        return (0, core_1.difficulty)(this.difficultyFactors, (0, viem_1.hexToBytes)(data).length);
+    }
+    /**
+     * Calls the provider RPC directly
+     * @param method the method to call
+     * @param params the parameters to pass to the method
+     * @returns the response from the RPC
+     */
+    async request(arg) {
+        this.log('%s(%o)', arg.method, arg.params);
+        return this.provider.request(arg);
+    }
+}
+exports.MsgBoardClient = MsgBoardClient;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/logger.d.ts

@@ -0,0 +1,4 @@
+import Debug from 'debug';
+declare const _default: Debug.Debugger;
+export default _default;
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;;AAEzB,wBAAgC"}

package/dist/logger.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const debug_1 = __importDefault(require("debug"));
+exports.default = (0, debug_1.default)('msgboard');
+//# sourceMappingURL=logger.js.map

package/dist/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":";;;;;AAAA,kDAAyB;AAEzB,kBAAe,IAAA,eAAK,EAAC,UAAU,CAAC,CAAA"}

package/dist/render-reference.d.ts

@@ -0,0 +1,44 @@
+/** Renders an OpenRPC document into a markdown API reference. Pure: no file I/O. */
+type Schema = {
+    $ref?: string;
+    title?: string;
+    type?: string;
+    description?: string;
+    pattern?: string;
+    items?: Schema;
+    properties?: Record<string, Schema>;
+    required?: string[];
+    additionalProperties?: Schema | boolean;
+};
+type Param = {
+    name: string;
+    required?: boolean;
+    schema: Schema;
+};
+type Method = {
+    name: string;
+    summary?: string;
+    params: Param[];
+    result: {
+        name: string;
+        schema: Schema;
+    };
+    examples?: Array<{
+        name: string;
+        params: Array<{
+            value: unknown;
+        }>;
+        result: {
+            value: unknown;
+        };
+    }>;
+};
+type Doc = {
+    methods: Method[];
+    components: {
+        schemas: Record<string, Schema>;
+    };
+};
+export declare const renderReference: (doc: Doc) => string;
+export {};
+//# sourceMappingURL=render-reference.d.ts.map

package/dist/render-reference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-reference.d.ts","sourceRoot":"","sources":["../src/render-reference.ts"],"names":[],"mappings":"AAAA,oFAAoF;AAEpF,KAAK,MAAM,GAAG;IACZ,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;IACnB,oBAAoB,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;CACxC,CAAA;AACD,KAAK,KAAK,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AACjE,KAAK,MAAM,GAAG;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,KAAK,EAAE,CAAA;IACf,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;IACxC,QAAQ,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,KAAK,CAAC;YAAE,KAAK,EAAE,OAAO,CAAA;SAAE,CAAC,CAAC;QAAC,MAAM,EAAE;YAAE,KAAK,EAAE,OAAO,CAAA;SAAE,CAAA;KAAE,CAAC,CAAA;CAClG,CAAA;AACD,KAAK,GAAG,GAAG;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,UAAU,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,CAAA;CAAE,CAAA;AA0DjF,eAAO,MAAM,eAAe,GAAI,KAAK,GAAG,KAAG,MAO1C,CAAA"}

package/dist/render-reference.js

@@ -0,0 +1,74 @@
+"use strict";
+/** Renders an OpenRPC document into a markdown API reference. Pure: no file I/O. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderReference = void 0;
+const refName = (schema) => {
+    if (schema.$ref)
+        return schema.$ref.split('/').pop();
+    if (schema.type === 'array' && schema.items)
+        return `${refName(schema.items)}[]`;
+    return schema.type ?? 'any';
+};
+const renderMethod = (m) => {
+    const lines = [];
+    lines.push(`### ${m.name}`, '');
+    if (m.summary)
+        lines.push(m.summary, '');
+    lines.push('| Parameter | Type | Required |', '| --- | --- | --- |');
+    if (m.params.length === 0) {
+        lines.push('| _(none)_ | | |');
+    }
+    else {
+        for (const p of m.params) {
+            lines.push(`| \`${p.name}\` | \`${refName(p.schema)}\` | ${p.required ? 'yes' : 'no'} |`);
+        }
+    }
+    lines.push('', `**Returns:** \`${refName(m.result.schema)}\``, '');
+    const example = m.examples?.[0];
+    if (example) {
+        const req = { jsonrpc: '2.0', id: 1, method: m.name, params: example.params.map((p) => p.value) };
+        const res = { jsonrpc: '2.0', id: 1, result: example.result.value };
+        lines.push('```json', JSON.stringify(req, null, 2), '```', '');
+        lines.push('```json', JSON.stringify(res, null, 2), '```', '');
+    }
+    return lines.join('\n');
+};
+const renderSchema = (name, schema) => {
+    const lines = [];
+    lines.push(`### ${name}`, '');
+    if (schema.description)
+        lines.push(schema.description, '');
+    if (schema.type === 'string' && schema.pattern) {
+        lines.push(`String matching \`${schema.pattern}\`.`, '');
+        return lines.join('\n');
+    }
+    if (schema.type === 'array' && schema.items) {
+        lines.push(`Array of \`${refName(schema.items)}\`.`, '');
+        return lines.join('\n');
+    }
+    if (schema.properties) {
+        lines.push('| Field | Type | Description |', '| --- | --- | --- |');
+        for (const [field, prop] of Object.entries(schema.properties)) {
+            const required = schema.required?.includes(field) ? ' (required)' : '';
+            lines.push(`| \`${field}\`${required} | \`${refName(prop)}\` | ${prop.description ?? ''} |`);
+        }
+        lines.push('');
+        return lines.join('\n');
+    }
+    if (typeof schema.additionalProperties === 'object') {
+        lines.push(`Object whose values are \`${refName(schema.additionalProperties)}\`.`, '');
+    }
+    return lines.join('\n');
+};
+const renderReference = (doc) => {
+    const out = [];
+    out.push('## JSON-RPC methods', '');
+    for (const m of doc.methods)
+        out.push(renderMethod(m));
+    out.push('## Schemas', '');
+    for (const [name, schema] of Object.entries(doc.components.schemas))
+        out.push(renderSchema(name, schema));
+    return out.join('\n').trimEnd() + '\n';
+};
+exports.renderReference = renderReference;
+//# sourceMappingURL=render-reference.js.map

package/dist/render-reference.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-reference.js","sourceRoot":"","sources":["../src/render-reference.ts"],"names":[],"mappings":"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"}

package/openrpc.json

@@ -0,0 +1,97 @@
+{
+  "openrpc": "1.2.6",
+  "info": {
+    "title": "MsgBoard JSON-RPC API",
+    "version": "0.0.28",
+    "description": "JSON-RPC methods exposed by the msgboard_ module. Any node running the module serves these methods. Proof of work, not a fee, gates message submission.",
+    "license": { "name": "MIT" }
+  },
+  "methods": [
+    {
+      "name": "msgboard_status",
+      "summary": "Board status and the difficulty factors required for valid messages.",
+      "params": [],
+      "result": { "name": "status", "schema": { "$ref": "#/components/schemas/Status" } },
+      "examples": [
+        { "name": "default", "params": [], "result": { "name": "status", "value": { "enabled": true, "count": "0x0", "size": "0x0", "workMultiplier": "0x2710", "workDivisor": "0xf4240" } } }
+      ]
+    },
+    {
+      "name": "msgboard_categories",
+      "summary": "The list of 32-byte category hashes currently present on the board.",
+      "params": [],
+      "result": { "name": "categories", "schema": { "$ref": "#/components/schemas/Categories" } },
+      "examples": [
+        { "name": "gasmoneyplease", "params": [], "result": { "name": "categories", "value": ["0x6761736d6f6e6579706c65617365000000000000000000000000000000000000"] } }
+      ]
+    },
+    {
+      "name": "msgboard_content",
+      "summary": "All messages on the board, grouped by category hash. Optionally filtered.",
+      "params": [ { "name": "filter", "required": false, "schema": { "$ref": "#/components/schemas/ContentFilter" } } ],
+      "result": { "name": "content", "schema": { "$ref": "#/components/schemas/Content" } },
+      "examples": [
+        { "name": "empty", "params": [{ "name": "filter", "value": {} }], "result": { "name": "content", "value": {} } }
+      ]
+    },
+    {
+      "name": "msgboard_addMessage",
+      "summary": "Submit a proof-of-work message (RLP-encoded) to the board.",
+      "params": [ { "name": "rlp", "required": true, "schema": { "$ref": "#/components/schemas/Hex" } } ],
+      "result": { "name": "hash", "schema": { "$ref": "#/components/schemas/Hex" } },
+      "examples": [
+        { "name": "submit", "params": [{ "name": "rlp", "value": "0xf800" }], "result": { "name": "hash", "value": "0x0d1e2f00000000000000000000000000000000000000000000000000c46845f9" } }
+      ]
+    },
+    {
+      "name": "msgboard_getMessage",
+      "summary": "Fetch a single message by its hash.",
+      "params": [ { "name": "hash", "required": true, "schema": { "$ref": "#/components/schemas/Hex" } } ],
+      "result": { "name": "message", "schema": { "$ref": "#/components/schemas/RPCMessage" } },
+      "examples": [
+        { "name": "zero", "params": [{ "name": "hash", "value": "0x0000000000000000000000000000000000000000000000000000000000000000" }], "result": { "name": "message", "value": { "version": "0x1", "blockHash": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x0", "category": "0x0000000000000000000000000000000000000000000000000000000000000000", "data": "0x0000000000000000000000000000000000000000000000000000000000000000", "nonce": "0x0", "hash": "0x0000000000000000000000000000000000000000000000000000000000000000", "workMultiplier": "0x0", "workDivisor": "0x0" } } }
+      ]
+    }
+  ],
+  "components": {
+    "schemas": {
+      "Hex": { "title": "Hex", "type": "string", "pattern": "^0x[0-9a-fA-F]*$" },
+      "Status": {
+        "title": "Status", "type": "object",
+        "required": ["enabled", "count", "size", "workMultiplier", "workDivisor"],
+        "properties": {
+          "enabled": { "type": "boolean", "description": "Whether the module is enabled on this node." },
+          "count": { "$ref": "#/components/schemas/Hex", "description": "Overall count of messages stored on the board." },
+          "size": { "$ref": "#/components/schemas/Hex", "description": "Overall size of messages stored on the board." },
+          "workMultiplier": { "$ref": "#/components/schemas/Hex", "description": "Factor that increases required work." },
+          "workDivisor": { "$ref": "#/components/schemas/Hex", "description": "Factor that decreases required work." }
+        }
+      },
+      "Categories": { "title": "Categories", "type": "array", "items": { "$ref": "#/components/schemas/Hex" } },
+      "ContentFilter": {
+        "title": "ContentFilter", "type": "object",
+        "properties": {
+          "category": { "$ref": "#/components/schemas/Hex", "description": "Restrict to one category hash." },
+          "fromBlock": { "$ref": "#/components/schemas/Hex", "description": "Lower block bound (hex quantity)." },
+          "toBlock": { "$ref": "#/components/schemas/Hex", "description": "Upper block bound (hex quantity)." }
+        }
+      },
+      "RPCMessage": {
+        "title": "RPCMessage", "type": "object",
+        "required": ["version", "blockHash", "blockNumber", "category", "data", "nonce", "hash", "workMultiplier", "workDivisor"],
+        "properties": {
+          "version": { "$ref": "#/components/schemas/Hex", "description": "Message/encoding version." },
+          "blockHash": { "$ref": "#/components/schemas/Hex", "description": "Hash of the block the message is rooted to." },
+          "blockNumber": { "$ref": "#/components/schemas/Hex", "description": "Number of the block the message is rooted to." },
+          "category": { "$ref": "#/components/schemas/Hex", "description": "32-byte category hash." },
+          "data": { "$ref": "#/components/schemas/Hex", "description": "Arbitrary message data." },
+          "nonce": { "$ref": "#/components/schemas/Hex", "description": "Nonce discovered through proof of work." },
+          "hash": { "$ref": "#/components/schemas/Hex", "description": "The message hash." },
+          "workMultiplier": { "$ref": "#/components/schemas/Hex", "description": "Work multiplier in force when posted." },
+          "workDivisor": { "$ref": "#/components/schemas/Hex", "description": "Work divisor in force when posted." }
+        }
+      },
+      "Content": { "title": "Content", "type": "object", "description": "Messages grouped by category hash.", "additionalProperties": { "type": "array", "items": { "$ref": "#/components/schemas/RPCMessage" } } }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@msgboard/sdk",
+  "version": "0.0.28",
+  "description": "MsgBoard client SDK for the msgboard_ JSON-RPC module",
+  "repository": "github:valve-tech/msgboard",
+  "author": "MsgBoard",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "commonjs": "./dist/index.js",
+  "exports": {
+    ".": {
+      "require": "./dist/index.js",
+      "default": "./dist/index.js",
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "keywords": [
+    "ethereum",
+    "smart-contracts",
+    "pow",
+    "proof-of-work"
+  ],
+  "scripts": {
+    "lint:fix": "eslint --fix --format=stylish src",
+    "lint": "eslint --format=stylish src",
+    "test": "DEBUG=msgboard vitest run",
+    "prebuild": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
+    "build": "tsc",
+    "watch": "tsc -w",
+    "gen:docs": "tsx scripts/generate-reference.ts"
+  },
+  "files": [
+    "dist/",
+    "openrpc.json"
+  ],
+  "devDependencies": {
+    "@eslint/js": "^9.25.1",
+    "@open-rpc/schema-utils-js": "^2.2.1",
+    "@types/bn.js": "^5.1.6",
+    "@types/debug": "^4.1.12",
+    "@types/elliptic": "^6.4.18",
+    "@typescript-eslint/eslint-plugin": "^8.29.0",
+    "@typescript-eslint/parser": "^8.29.0",
+    "eslint": "^9.23.0",
+    "eslint-config-prettier": "^10.1.2",
+    "eslint-plugin-prettier": "^5.2.6",
+    "ethers": "^6.13.5",
+    "globals": "^16.0.0",
+    "jiti": "^2.4.2",
+    "tsx": "^4.19.3",
+    "typescript": "^5.8.2",
+    "typescript-eslint": "^8.31.0",
+    "vitest": "^3.1.1"
+  },
+  "dependencies": {
+    "@msgboard/core": "^0.0.1",
+    "bn.js": "^5.2.1",
+    "debug": "^4.4.0",
+    "elliptic": "^6.6.1",
+    "viem": "^2.25.0"
+  }
+}