@msgboard/hardhat 0.0.1

package/README.md

@@ -0,0 +1,77 @@
+# @pulsechain/hardhat-msgboard
+
+Test your msgboard interfaces
+
+[Hardhat](https://hardhat.org) plugin example.
+
+## MsgBoard
+
+MsgBoard allows for decentralized, public communication. Each msgboard instance may behave slightly differently quirks, but so long as the basic interface holds true, it can reliably push the ability to run software closer to the individual. One needs to tightly control which process is utilizing msgboard because it will block as it works through and eventually finds a valid hash.
+
+## Installation
+
+After installing nodejs (+23.6.1 with asdf recommended)
+
+```bash
+npm install @pulsechain/hardhat-msgboard
+```
+
+Import the plugin in your `hardhat.config.js`:
+
+```js
+require("@pulsechain/hardhat-msgboard");
+```
+
+Or if you are using TypeScript, in your `hardhat.config.ts`:
+
+```ts
+import "@pulsechain/hardhat-msgboard";
+```
+
+## Tasks
+
+`msgboard:status`
+`msgboard:work`
+`msgboard:send`
+`msgboard:work:send`
+
+```sh
+> hardhat msgboard:status
+```
+
+## Environment extensions
+
+<_A description of each extension to the Hardhat Runtime Environment_>
+
+This plugin extends the Hardhat Runtime Environment by adding an `example` field
+whose type is `ExampleHardhatRuntimeEnvironmentField`.
+
+## Configuration
+
+<_A description of each extension to the HardhatConfig or to its fields_>
+
+This plugin extends the `HardhatUserConfig`'s `MsgBoardUserConfig` object with an optional `msgboard` field that is only applicable to the hardhat network.
+
+This is an example of how to set it:
+
+```ts
+module.exports = {
+  msgboard: {
+    // only applicable to hardhat network
+    enabled: true,
+    workMultiplier: 1_000_000n,
+    workDivisor: 10_000n,
+    messageSizeLimit: 8n * 1024n,
+    boardCountLimit: 10_000n,
+    blockRangeLimit: 120n,
+  },
+};
+```
+
+## Usage
+
+send messages to the msgboard and read from it
+
+```ts
+const msg = await hre.msgboard.doWork('0xcategory...', '0xdata...')
+```

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import './type-extensions';
+import './tasks';

package/dist/index.js

@@ -0,0 +1,67 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("hardhat/config");
+const plugins_1 = require("hardhat/plugins");
+const msgboard = __importStar(require("@msgboard/sdk"));
+const provider_1 = require("./provider");
+// This import is needed to let the TypeScript compiler know that it should include your type
+// extensions in your npm package's types file.
+require("./type-extensions");
+require("./tasks");
+(0, config_1.extendConfig)((config, userConfig) => {
+    const userConf = userConfig;
+    const c = config;
+    c.msgboard = {
+        ...provider_1.globalDefaultSettings,
+        ...(userConf.msgboard ?? {}),
+    };
+});
+(0, config_1.extendEnvironment)((hre) => {
+    // We add a field to the Hardhat Runtime Environment here.
+    // We use lazyObject to avoid initializing things until they are actually
+    // needed.
+    hre.msgboard = (0, plugins_1.lazyObject)(() => {
+        return new msgboard.MsgBoardClient(msgboard.wrapLegacySend(hre.network.provider));
+    });
+});
+(0, config_1.extendProvider)((provider, config, network) => {
+    const isHardhatNetwork = network === 'hardhat';
+    const c = config;
+    const prov = new provider_1.MsgBoardProvider(provider, isHardhatNetwork);
+    prov.setNodeConstraints(c);
+    provider_1.providers.add(prov);
+    return prov;
+});

package/dist/provider.d.ts

@@ -0,0 +1,113 @@
+import { ProviderWrapper } from 'hardhat/plugins';
+import type { EIP1193Provider, RequestArguments } from 'hardhat/types';
+import type { MsgBoardSettings } from './types';
+export declare const globalDefaultSettings: MsgBoardSettings;
+export declare const defaultSettings: () => {
+    enabled: boolean;
+    workMultiplier: bigint;
+    workDivisor: bigint;
+    messageSizeLimit: bigint;
+    boardCountLimit: bigint;
+    blockRangeLimit: bigint;
+};
+export declare class MsgBoardProvider extends ProviderWrapper {
+    protected readonly _wrappedProvider: EIP1193Provider;
+    protected readonly isHardhatNetwork: boolean;
+    private messages;
+    id: number;
+    private settings;
+    constructor(_wrappedProvider: EIP1193Provider, isHardhatNetwork: boolean);
+    /**
+     * Returns the default settings for a msgboard instance
+     * @returns The default settings for a msgboard instance
+     */
+    static defaultSettings(): {
+        enabled: boolean;
+        workMultiplier: bigint;
+        workDivisor: bigint;
+        messageSizeLimit: bigint;
+        boardCountLimit: bigint;
+        blockRangeLimit: bigint;
+    };
+    /**
+     * Returns the status of the msgboard
+     * @returns The status object of this message board instance
+     */
+    private status;
+    /**
+     * Sets the constraints for this message board instance
+     * @param constraints The constraints to set for this message board instance
+     */
+    setNodeConstraints(constraints?: Partial<MsgBoardSettings>): Promise<void>;
+    /**
+     * Validates a message
+     * @param m The message to validate
+     * @returns The validated message and the produced hash
+     */
+    private validateMessage;
+    /**
+     * Adds a message to the msgboard
+     * @param msg The rlp encoded message to add
+     * @returns The hash of the message
+     */
+    private addMessage;
+    /**
+     * Adds a message to the msgboard in order
+     * @param latestBlockNumber The latest block number
+     * - to be passed to the removeStaleMessages method to prune old messages
+     * @param m The message to add
+     */
+    private addOrderedMessage;
+    /**
+     * Removes stale messages from the msgboard
+     * @param latestBlockNumber The latest block number - used to prune old messages
+     */
+    private removeStaleMessages;
+    /**
+     * Returns a message from the msgboard by hash
+     * @param hash The hash of the message to return
+     * @returns The message or null if it is not found
+     */
+    private getMessage;
+    /**
+     * Returns the content of the msgboard
+     * @param filter The filter to apply to the content
+     * @returns The content of the msgboard
+     */
+    private content;
+    /**
+     * Returns the categories of the msgboard
+     * @returns The categories of the msgboard
+     */
+    private categories;
+    /**
+     * Handles a msgboard request
+     * @param args The request arguments
+     * @returns The result of the request
+     */
+    private handleMsgboardRequest;
+    /**
+     * Emulates network latency by adding a XXms delay before and after the function call
+     * @param fn The function to execute
+     * @returns The result of the function
+     */
+    private emulateNetworkLatency;
+    /**
+     * Handles a request to the msgboard, handling it locally if the network is hardhat
+     * @param args The request arguments
+     * @returns The result of the request
+     */
+    request(args: RequestArguments): Promise<unknown>;
+    /**
+     * Resets the msgboard
+     */
+    reset(): void;
+    destroy(): void;
+}
+export declare const providers: Set<MsgBoardProvider>;
+/**
+ * Sets the constraints for all created msgboard providers
+ * @param constraints The settings to apply to all msgboard providers
+ */
+export declare const setNodeConstraints: (constraints: Partial<MsgBoardSettings>) => void;
+export declare const reset: () => void;

package/dist/provider.js

@@ -0,0 +1,337 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reset = exports.setNodeConstraints = exports.providers = exports.MsgBoardProvider = exports.defaultSettings = exports.globalDefaultSettings = void 0;
+const plugins_1 = require("hardhat/plugins");
+const viem_1 = require("viem");
+const msgboard = __importStar(require("@msgboard/sdk"));
+exports.globalDefaultSettings = {
+    enabled: true,
+    workMultiplier: 10000n,
+    workDivisor: 1000000n,
+    messageSizeLimit: 1024n * 8n,
+    boardCountLimit: 10000n,
+    blockRangeLimit: 120n,
+};
+const defaultSettings = () => ({
+    ...exports.globalDefaultSettings,
+});
+exports.defaultSettings = defaultSettings;
+/**
+ * Waits for a given number of milliseconds
+ * @param ms The number of milliseconds to wait
+ */
+const wait = async (ms) => {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+};
+const isNil = (value) => value === null || value === undefined;
+let id = 0;
+class MsgBoardProvider extends plugins_1.ProviderWrapper {
+    constructor(_wrappedProvider, isHardhatNetwork) {
+        super(_wrappedProvider);
+        this._wrappedProvider = _wrappedProvider;
+        this.isHardhatNetwork = isHardhatNetwork;
+        this.messages = [];
+        this.settings = {
+            ...exports.globalDefaultSettings,
+        };
+        this.id = ++id;
+    }
+    /**
+     * Returns the default settings for a msgboard instance
+     * @returns The default settings for a msgboard instance
+     */
+    static defaultSettings() {
+        return {
+            ...exports.globalDefaultSettings,
+        };
+    }
+    /**
+     * Returns the status of the msgboard
+     * @returns The status object of this message board instance
+     */
+    status() {
+        return {
+            enabled: this.settings.enabled,
+            workMultiplier: (0, viem_1.numberToHex)(this.settings.workMultiplier),
+            workDivisor: (0, viem_1.numberToHex)(this.settings.workDivisor),
+            count: (0, viem_1.numberToHex)(this.messages.length),
+            size: (0, viem_1.numberToHex)(this.messages.reduce((acc, msg) => acc + msg.data.length, 0)),
+        };
+    }
+    /**
+     * Sets the constraints for this message board instance
+     * @param constraints The constraints to set for this message board instance
+     */
+    async setNodeConstraints(constraints = {}) {
+        this.settings = { ...this.settings, ...constraints };
+    }
+    /**
+     * Validates a message
+     * @param m The message to validate
+     * @returns The validated message and the produced hash
+     */
+    async validateMessage(m) {
+        // these errors may be out of order compared to the current node implementation
+        const bytes = (0, viem_1.hexToBytes)(m.data);
+        if (bytes.length > this.settings.messageSizeLimit) {
+            throw new Error('msgboard: message too large');
+        }
+        if (m.version !== 1) {
+            throw new Error('powmsg: invalid version');
+        }
+        if ((0, viem_1.hexToBytes)(m.category).length !== 32) {
+            throw new Error('powmsg: invalid category');
+        }
+        if (m.blockHash === viem_1.zeroHash) {
+            throw new Error('powmsg: invalid block hash');
+        }
+        if (m.nonce === 0n) {
+            throw new Error('powmsg: invalid nonce');
+        }
+        if (m.workDivisor === 0n || m.workMultiplier === 0n) {
+            throw new Error('powmsg: invalid difficulty');
+        }
+        const difficultyFactors = {
+            workMultiplier: this.settings.workMultiplier,
+            workDivisor: this.settings.workDivisor,
+        };
+        if (m.category === viem_1.zeroHash && m.data.length !== 0) {
+            throw new Error('powmsg: invalid data');
+        }
+        const difficulty = msgboard.difficulty(difficultyFactors, bytes.length);
+        const hash = msgboard.checkWork(m, difficulty);
+        if (!hash) {
+            if (difficultyFactors.workMultiplier !== this.settings.workMultiplier ||
+                difficultyFactors.workDivisor !== this.settings.workDivisor) {
+                console.log(this.id, difficultyFactors, m);
+            }
+            throw new Error('powmsg: invalid work');
+        }
+        const block = (await this._wrappedProvider.request({
+            method: 'eth_getBlockByHash',
+            params: [m.blockHash, false],
+        }));
+        if (!block) {
+            throw new Error('powmsg: invalid block hash');
+        }
+        return { hash, block };
+    }
+    /**
+     * Adds a message to the msgboard
+     * @param msg The rlp encoded message to add
+     * @returns The hash of the message
+     */
+    async addMessage(msg) {
+        const m = msgboard.fromRLP(msg);
+        const { hash, block: workBlock } = await this.validateMessage(m);
+        const latestBlock = (await this._wrappedProvider.request({
+            method: 'eth_getBlockByNumber',
+            params: ['latest', false],
+        }));
+        const latestBlockNumber = BigInt(latestBlock.number);
+        const workBlockNumber = BigInt(workBlock.number);
+        if (
+        // could swap out for bignumber.js to avoid precision issues
+        Number(m.workMultiplier) / Number(m.workDivisor) >
+            Number(this.settings.workMultiplier) / Number(this.settings.workDivisor)) {
+            throw new Error('msgboard: message work too easy');
+        }
+        if (workBlockNumber < latestBlockNumber - this.settings.blockRangeLimit) {
+            throw new Error('msgboard: message block too old');
+        }
+        this.addOrderedMessage(latestBlockNumber, {
+            ...m,
+            blockNumber: workBlockNumber,
+            hash,
+        });
+        return hash;
+    }
+    /**
+     * Adds a message to the msgboard in order
+     * @param latestBlockNumber The latest block number
+     * - to be passed to the removeStaleMessages method to prune old messages
+     * @param m The message to add
+     */
+    addOrderedMessage(latestBlockNumber, m) {
+        const index = this.messages.findIndex((msg) => {
+            return msg.blockNumber > m.blockNumber;
+        });
+        if (index === -1) {
+            this.messages.push(m);
+        }
+        else {
+            this.messages.splice(index, 0, m);
+        }
+        this.removeStaleMessages(latestBlockNumber);
+    }
+    /**
+     * Removes stale messages from the msgboard
+     * @param latestBlockNumber The latest block number - used to prune old messages
+     */
+    removeStaleMessages(latestBlockNumber) {
+        // remove messages that are too old
+        const finalValidBlockNumber = latestBlockNumber - this.settings.blockRangeLimit;
+        const index = this.messages.findIndex((msg) => {
+            return msg.blockNumber >= finalValidBlockNumber;
+        });
+        if (index !== -1) {
+            this.messages.splice(0, index);
+        }
+        // remove messages when the board count limit is exceeded
+        if (BigInt(this.messages.length) > this.settings.boardCountLimit) {
+            this.messages.splice(0, this.messages.length - Number(this.settings.boardCountLimit));
+        }
+    }
+    /**
+     * Returns a message from the msgboard by hash
+     * @param hash The hash of the message to return
+     * @returns The message or null if it is not found
+     */
+    getMessage(hash) {
+        const msg = this.messages.find((msg) => msg.hash === hash) ?? null;
+        return !msg ? null : msgboard.toRPCMessage(msg);
+    }
+    /**
+     * Returns the content of the msgboard
+     * @param filter The filter to apply to the content
+     * @returns The content of the msgboard
+     */
+    content(filter = {}) {
+        return this.messages.reduce((content, msg) => {
+            if (filter.category && msg.category !== filter.category) {
+                // message category does not match filter category
+                return content;
+            }
+            if (!isNil(filter.fromBlock) && msg.blockNumber < filter.fromBlock) {
+                // message block number is below lower bound block number
+                return content;
+            }
+            if (!isNil(filter.toBlock) && msg.blockNumber > filter.toBlock) {
+                // message block number is above upper bound block number
+                return content;
+            }
+            if (!content[msg.category]) {
+                content[msg.category] = [];
+            }
+            content[msg.category].push(msgboard.toRPCMessage(msg));
+            return content;
+        }, {});
+    }
+    /**
+     * Returns the categories of the msgboard
+     * @returns The categories of the msgboard
+     */
+    categories() {
+        return Array.from(new Set(this.messages.map((msg) => msg.category)));
+    }
+    /**
+     * Handles a msgboard request
+     * @param args The request arguments
+     * @returns The result of the request
+     */
+    handleMsgboardRequest(args) {
+        if (args.method === 'msgboard_status') {
+            return this.status(...args.params);
+        }
+        if (args.method === 'msgboard_addMessage') {
+            return this.addMessage(...args.params);
+        }
+        if (args.method === 'msgboard_getMessage') {
+            return this.getMessage(...args.params);
+        }
+        if (args.method === 'msgboard_content') {
+            return this.content(...args.params);
+        }
+        if (args.method === 'msgboard_categories') {
+            return this.categories(...args.params);
+        }
+        // only for local hardhat network - does not exist on production networks
+        if (args.method === 'msgboard_reset') {
+            return this.reset(...args.params);
+        }
+        throw new Error('msgboard: unknown method');
+    }
+    /**
+     * Emulates network latency by adding a XXms delay before and after the function call
+     * @param fn The function to execute
+     * @returns The result of the function
+     */
+    async emulateNetworkLatency(fn) {
+        await wait(2);
+        const result = await fn();
+        await wait(2);
+        return result;
+    }
+    /**
+     * Handles a request to the msgboard, handling it locally if the network is hardhat
+     * @param args The request arguments
+     * @returns The result of the request
+     */
+    async request(args) {
+        if (this.isHardhatNetwork && args.method.startsWith('msgboard_')) {
+            return this.emulateNetworkLatency(() => this.handleMsgboardRequest(args));
+        }
+        return this._wrappedProvider.request(args);
+    }
+    /**
+     * Resets the msgboard
+     */
+    reset() {
+        this.messages = [];
+    }
+    destroy() {
+        this.reset();
+        exports.providers.delete(this);
+    }
+}
+exports.MsgBoardProvider = MsgBoardProvider;
+exports.providers = new Set();
+/**
+ * Sets the constraints for all created msgboard providers
+ * @param constraints The settings to apply to all msgboard providers
+ */
+const setNodeConstraints = (constraints) => {
+    Array.from(exports.providers).forEach((p) => {
+        p.setNodeConstraints(constraints);
+    });
+};
+exports.setNodeConstraints = setNodeConstraints;
+const reset = () => {
+    Array.from(exports.providers).forEach((p) => {
+        p.reset();
+    });
+};
+exports.reset = reset;

package/dist/tasks.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tasks.js

@@ -0,0 +1,298 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("hardhat/config");
+const viem_1 = require("viem");
+const msgboard = __importStar(require("@msgboard/sdk"));
+const argumentTypes = __importStar(require("hardhat/internal/core/params/argumentTypes"));
+const options = {
+    // params
+    category: ['category', 'the category of the work', '', argumentTypes.string],
+    data: ['data', 'the data of the work', '', argumentTypes.string],
+    rlp: ['rlp', 'the rlp of the message', '', argumentTypes.string],
+    messageJson: ['message', 'the decoded message to send', 'null', argumentTypes.string],
+    hash: ['hash', 'the hash of the message', '', argumentTypes.string],
+    // optional params
+    board: ['board', 'the board to use (programmatic only - no CLI)', null, argumentTypes.any],
+    message: ['message', 'the decoded message to send', null, argumentTypes.any],
+    fromBlock: ['fromBlock', 'the block number to start from', null, argumentTypes.bigint],
+    toBlock: ['toBlock', 'the block number to end at', null, argumentTypes.bigint],
+    size: ['size', 'the number of bytes to calculate the difficulty for', 0, argumentTypes.int],
+    workMultiplier: ['workMultiplier', 'the work multiplier', 0n, argumentTypes.bigint],
+    workDivisor: ['workDivisor', 'the work divisor', 0n, argumentTypes.bigint],
+    // flags
+    log: ['log', 'log the status'],
+};
+const descriptions = {
+    status: 'Gets the status of the msgboard',
+    work: 'Produce a proof of work for a given category and data',
+    send: 'Send an RLP encoded message to the msgboard',
+    sendDecoded: 'Send a decoded message to the msgboard',
+    workSend: 'Produce and send a proof of work to the msgboard',
+    getMessage: 'Get a message from the msgboard',
+    reset: 'Reset the msgboard',
+    categories: 'Get the categories of the msgboard',
+    content: 'Get the content of the msgboard',
+    getDifficulty: 'Calculate the difficulty for a given number of bytes',
+};
+const taskNames = {
+    status: 'status',
+    work: 'work',
+    send: 'send',
+    sendDecoded: 'send-decoded',
+    workSend: 'work:send',
+    getMessage: 'get-message',
+    reset: 'reset',
+    categories: 'categories',
+    content: 'content',
+    getDifficulty: 'get-difficulty',
+};
+const globalTaskName = (taskName) => `${scopeKey}:${taskName}`;
+const scopeKey = 'msgboard';
+const scoped = (0, config_1.scope)(scopeKey, 'A scope for msgboard tasks');
+const omitNull = (obj) => Object.fromEntries(Object.entries(obj).filter(([_, v]) => v !== null && v !== undefined));
+scoped.subtask(globalTaskName(taskNames.status))
+    .setDescription(descriptions.status)
+    .addOptionalParam(...options.board)
+    .addFlag(...options.log)
+    .setAction(async (taskArgs, hre) => {
+    const board = (taskArgs.board ?? hre.msgboard);
+    const status = await board.status();
+    if (taskArgs.log) {
+        board.log('status: %o', {
+            enabled: status.enabled,
+            workMultiplier: BigInt(status.workMultiplier),
+            workDivisor: BigInt(status.workDivisor),
+            count: BigInt(status.count),
+            size: BigInt(status.size),
+        });
+    }
+    return status;
+});
+scoped.task(taskNames.status)
+    .setDescription(descriptions.status)
+    .addFlag(...options.log)
+    .setAction(async (taskArgs, hre) => {
+    return hre.run({
+        scope: scopeKey,
+        task: globalTaskName(taskNames.status),
+    }, omitNull(taskArgs));
+});
+scoped.subtask(globalTaskName(taskNames.work))
+    .setDescription(descriptions.work)
+    .addParam(...options.category)
+    .addParam(...options.data)
+    .addFlag(...options.log)
+    .addOptionalParam(...options.board)
+    .setAction(async (taskArgs, hre) => {
+    const { category, data, board: b, log } = taskArgs;
+    const d = msgboard.encodeData(data);
+    const c = (0, viem_1.isHex)(category) ? (0, viem_1.toHex)(category, { size: 32 }) : (0, viem_1.keccak256)((0, viem_1.stringToBytes)(category));
+    const board = (b ?? hre.msgboard);
+    const work = await board.doPoW(c, d);
+    if (log) {
+        board.log('work: %o', work);
+    }
+    return work;
+});
+scoped.task(taskNames.work)
+    .setDescription(descriptions.work)
+    .setAction(async (taskArgs, hre) => {
+    return hre.run({
+        scope: scopeKey,
+        task: globalTaskName(taskNames.work),
+    }, omitNull(taskArgs));
+});
+scoped.subtask(globalTaskName(taskNames.send))
+    .setDescription(descriptions.send)
+    .addParam(...options.rlp)
+    .addOptionalParam(...options.board)
+    .setAction(async (taskArgs, hre) => {
+    const { rlp, board: b } = taskArgs;
+    const board = (b ?? hre.msgboard);
+    return await board.addMessage(rlp);
+});
+scoped.task(taskNames.send)
+    .setDescription(descriptions.send)
+    .setAction(async (taskArgs, hre) => {
+    return hre.run({
+        scope: scopeKey,
+        task: globalTaskName(taskNames.send),
+    }, omitNull(taskArgs));
+});
+scoped.subtask(globalTaskName(taskNames.sendDecoded))
+    .setDescription(descriptions.sendDecoded)
+    .addParam(...options.message)
+    .addOptionalParam(...options.board)
+    .setAction(async (taskArgs, hre) => {
+    const { message, board: b } = taskArgs;
+    return await hre.run({
+        scope: scopeKey,
+        task: globalTaskName(taskNames.send),
+    }, {
+        rlp: msgboard.toRLP(message),
+        board: b,
+    });
+});
+scoped.task(taskNames.sendDecoded)
+    .setDescription(descriptions.sendDecoded)
+    .setAction(async (taskArgs, hre) => {
+    return hre.run({
+        scope: scopeKey,
+        task: globalTaskName(taskNames.sendDecoded),
+    }, {
+        ...taskArgs,
+        message: JSON.parse(taskArgs.message),
+    });
+});
+scoped.subtask(globalTaskName(taskNames.workSend))
+    .setDescription(descriptions.workSend)
+    .addParam(...options.category)
+    .addParam(...options.data)
+    .addOptionalParam(...options.board)
+    .addFlag(...options.log)
+    .setAction(async (taskArgs, hre) => {
+    const board = (taskArgs.board ?? hre.msgboard);
+    const work = (await hre.run({
+        scope: scopeKey,
+        task: globalTaskName(taskNames.work),
+    }, {
+        ...taskArgs,
+        board,
+    }));
+    return await hre.run({
+        scope: scopeKey,
+        task: globalTaskName(taskNames.sendDecoded),
+    }, {
+        message: work.message,
+        board,
+    });
+});
+scoped.task(taskNames.workSend)
+    .setDescription(descriptions.workSend)
+    .addFlag(...options.log)
+    .addParam(...options.category)
+    .addParam(...options.data)
+    .setAction(async (taskArgs, hre) => {
+    return hre.run({
+        scope: scopeKey,
+        task: globalTaskName(taskNames.workSend),
+    }, omitNull(taskArgs));
+});
+scoped.subtask(globalTaskName(taskNames.getMessage))
+    .setDescription(descriptions.getMessage)
+    .addParam(...options.hash)
+    .addOptionalParam(...options.board)
+    .setAction(async (taskArgs, hre) => {
+    const { hash, board: b } = taskArgs;
+    const board = (b ?? hre.msgboard);
+    return await board.getMessage(hash);
+});
+scoped.task(taskNames.getMessage)
+    .setDescription(descriptions.getMessage)
+    .addParam(...options.hash)
+    .setAction(async (taskArgs, hre) => {
+    return hre.run({
+        scope: scopeKey,
+        task: globalTaskName(taskNames.getMessage),
+    }, omitNull(taskArgs));
+});
+scoped.task(taskNames.reset)
+    .setDescription(descriptions.reset)
+    .setAction(async (_taskArgs, hre) => {
+    if (hre.network.name !== 'hardhat')
+        return;
+    await hre.network.provider.send('msgboard_reset', []);
+});
+scoped.task('categories')
+    .setDescription('Get the categories of the msgboard')
+    .setAction(async (_taskArgs, hre) => {
+    return await hre.network.provider.send('msgboard_categories', []);
+});
+scoped.subtask(globalTaskName(taskNames.content))
+    .setDescription(descriptions.content)
+    .addOptionalParam(...options.board)
+    .addOptionalParam(...options.category)
+    .addOptionalParam(...options.fromBlock)
+    .addOptionalParam(...options.toBlock)
+    .setAction(async (taskArgs, hre) => {
+    const { board: b, category, fromBlock, toBlock } = taskArgs;
+    const board = (b ?? hre.msgboard);
+    return await board.content({ category, fromBlock, toBlock });
+});
+scoped.task(taskNames.content)
+    .setDescription(descriptions.content)
+    .addOptionalParam(...options.category)
+    .addOptionalParam(...options.fromBlock)
+    .addOptionalParam(...options.toBlock)
+    .setAction(async (taskArgs, hre) => {
+    return hre.run({
+        scope: scopeKey,
+        task: globalTaskName(taskNames.content),
+    }, omitNull(taskArgs));
+});
+scoped.subtask(globalTaskName(taskNames.getDifficulty))
+    .setDescription(descriptions.getDifficulty)
+    .addOptionalParam(...options.data)
+    .addOptionalParam(...options.size)
+    .addOptionalParam(...options.workMultiplier)
+    .addOptionalParam(...options.workDivisor)
+    .addOptionalParam(...options.board)
+    .setAction(async (taskArgs, hre) => {
+    const { size, data, board: b, workMultiplier, workDivisor } = taskArgs;
+    const board = (b ?? hre.msgboard);
+    if (workMultiplier && workDivisor) {
+        board.setDifficultyFactors(workMultiplier, workDivisor);
+    }
+    else {
+        const status = await board.status().catch(() => null);
+        if (status)
+            board.setDifficultyFactors(BigInt(status.workMultiplier), BigInt(status.workDivisor));
+    }
+    const d = data ?? `0x${new Array(size * 2).fill(0).join('')}`;
+    return board.getDifficulty(d);
+});
+scoped.task(taskNames.getDifficulty)
+    .setDescription(descriptions.getDifficulty)
+    .addOptionalParam(...options.size)
+    .addOptionalParam(...options.data)
+    .addOptionalParam(...options.workMultiplier)
+    .addOptionalParam(...options.workDivisor)
+    .setAction(async (taskArgs, hre) => {
+    return hre.run({
+        scope: scopeKey,
+        task: globalTaskName(taskNames.getDifficulty),
+    }, omitNull(taskArgs));
+});

package/dist/type-extensions.d.ts

@@ -0,0 +1,17 @@
+import 'hardhat/types/config';
+import 'hardhat/types/runtime';
+import type { MsgBoardClient } from '@msgboard/sdk';
+import type { MsgBoardSettings } from './types';
+declare module 'hardhat/types/config' {
+    interface MsgBoardUserConfig {
+        msgboard?: Partial<MsgBoardSettings>;
+    }
+    interface MsgBoardConfig {
+        msgboard: MsgBoardSettings;
+    }
+}
+declare module 'hardhat/types/runtime' {
+    interface HardhatRuntimeEnvironment {
+        msgboard: MsgBoardClient;
+    }
+}

package/dist/type-extensions.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("hardhat/types/config");
+require("hardhat/types/runtime");

package/dist/types.d.ts

@@ -0,0 +1,8 @@
+export type MsgBoardSettings = {
+    enabled: boolean;
+    workMultiplier: bigint;
+    workDivisor: bigint;
+    messageSizeLimit: bigint;
+    boardCountLimit: bigint;
+    blockRangeLimit: bigint;
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@msgboard/hardhat",
+  "version": "0.0.1",
+  "description": "Hardhat plugin for MsgBoard",
+  "repository": "github:valve-tech/msgboard",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "commonjs": "dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./provider": {
+      "types": "./dist/provider.d.ts",
+      "require": "./dist/provider.js",
+      "import": "./dist/provider.js",
+      "default": "./dist/provider.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "require": "./dist/types.js",
+      "import": "./dist/types.js",
+      "default": "./dist/types.js"
+    },
+    "./tasks": {
+      "types": "./dist/tasks.d.ts",
+      "require": "./dist/tasks.js",
+      "import": "./dist/tasks.js",
+      "default": "./dist/tasks.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@nomicfoundation/hardhat-network-helpers": "^1.0.8",
+    "hardhat": "^2.16.1",
+    "nyc": "^17.1.0",
+    "solidity-coverage": "^0.8.15",
+    "tsx": "^4.19.3",
+    "viem": "^2.28.0",
+    "vitest": "^3.1.2"
+  },
+  "scripts": {
+    "prebuild": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
+    "build": "npm run compile",
+    "print": "hardhat help",
+    "watch": "npm run compile:watch",
+    "compile": "tsc && hardhat compile",
+    "compile:watch": "as-soon -w contracts npm run compile",
+    "test": "vitest",
+    "coverage": "hardhat compile-for-coverage && vitest run --coverage && hardhat compile",
+    "coverage:compile:watch": "as-soon -w contracts hardhat compile-for-coverage",
+    "coverage:watch": "hardhat compile-for-coverage && vitest --coverage"
+  },
+  "dependencies": {
+    "@msgboard/sdk": "^0.0.28"
+  }
+}