mofu-sdk 0.1.1 → 0.2.0

package/README.md

@@ -82,6 +82,19 @@ if (event.type === "owner_changed") pause(event.token!.address);
 
 `parseWebhook` throws when the signature is wrong or older than five minutes; `verifyWebhook` returns a boolean instead.
 
+## Read a verdict on-chain
+
+Mofu publishes verdicts to its MofuVerdicts registry on Robinhood Chain. Read one straight from the chain, without Mofu's API limits:
+
+```ts
+const v = await mofu.onchainVerdict(token); // finds the registry once via mofu.works
+v.verdict; // "clean" | "caution" | "risky" | null (not published)
+v.flags.sellFailed; // also honeypotCode, canMint, canPause, canBlock, upgradeable, fakeMofu
+v.scannedAt; // Date | null
+```
+
+Pass `{ registry, rpcUrl }` to skip the lookup or use your own node.
+
 ## Errors
 
 Failures throw `MofuError` with `status` and `code`: `daily_limit` (429), `bad_address` (400), `chain_unreachable` (503), `network` (Mofu couldn't be reached).

package/dist/index.d.ts

@@ -39,6 +39,14 @@ export declare class Mofu {
     scanToken(address: string): Promise<Checked<TokenReport>>;
     /** Wallet Health: every active approval (risky ones flagged) and the tokens a wallet holds. */
     checkWallet(address: string): Promise<Checked<WalletReport>>;
+    /**
+     * A token's verdict as published on Robinhood Chain (the MofuVerdicts registry), read straight
+     * from the chain with one eth_call. Pass `registry` to skip asking mofu.works where it is.
+     */
+    onchainVerdict(token: string, options?: {
+        registry?: string;
+        rpcUrl?: string;
+    }): Promise<OnchainVerdict>;
     /** Scans a token and applies a buy rule. Says no, with a reason, when Mofu can't be reached. */
     checkBeforeBuy(address: string, policy?: Partial<Policy>): Promise<Decision>;
     readonly webhooks: {
@@ -98,3 +106,21 @@ export declare function parseWebhook(signatureHeader: string | null | undefined,
     toleranceSeconds?: number;
     now?: number;
 }): Promise<WebhookEvent>;
+export interface OnchainVerdict {
+    registry: string;
+    /** null when Mofu hasn't published one for this token. */
+    verdict: "clean" | "caution" | "risky" | null;
+    flags: {
+        sellFailed: boolean;
+        honeypotCode: boolean;
+        canMint: boolean;
+        canPause: boolean;
+        canBlock: boolean;
+        upgradeable: boolean;
+        fakeMofu: boolean;
+    };
+    scannedAt: Date | null;
+    fingerprint: string | null;
+}
+/** Decodes verdictOf(address) → (uint8 verdict, uint8 flags, uint40 scannedAt, bytes16 fingerprint). */
+export declare function decodeOnchainVerdict(result: string, registry: string): OnchainVerdict;

package/dist/index.js

@@ -64,6 +64,41 @@ export class Mofu {
     checkWallet(address) {
         return this.call(`/api/v1/wallet/${Mofu.address(address, "address")}`);
     }
+    /**
+     * A token's verdict as published on Robinhood Chain (the MofuVerdicts registry), read straight
+     * from the chain with one eth_call. Pass `registry` to skip asking mofu.works where it is.
+     */
+    async onchainVerdict(token, options = {}) {
+        const address = Mofu.address(token, "token");
+        let registry = options.registry;
+        if (!registry) {
+            const info = await this.call("/api/v1/onchain");
+            if (!info.registry)
+                throw new MofuError("Mofu isn't publishing verdicts on-chain yet", 404, "not_published");
+            registry = info.registry;
+        }
+        const res = await this.fetchFn(options.rpcUrl ?? "https://robinhood-rpc.publicnode.com", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                jsonrpc: "2.0",
+                id: 1,
+                method: "eth_call",
+                // verdictOf(address)
+                params: [
+                    { to: registry, data: `0x371ad2ae${address.slice(2).padStart(64, "0")}` },
+                    "latest",
+                ],
+            }),
+            signal: AbortSignal.timeout(this.timeoutMs),
+        }).catch((err) => {
+            throw new MofuError(`Couldn't reach Robinhood Chain: ${err.message}`, 0, "network");
+        });
+        const body = (await res.json().catch(() => null));
+        if (!body?.result || body.result.length < 2 + 64 * 4)
+            throw new MofuError("Unexpected answer from the chain", 502, "bad_rpc");
+        return decodeOnchainVerdict(body.result, registry);
+    }
     /** Scans a token and applies a buy rule. Says no, with a reason, when Mofu can't be reached. */
     async checkBeforeBuy(address, policy = {}) {
         try {
@@ -170,3 +205,27 @@ export async function parseWebhook(signatureHeader, rawBody, secret, options) {
         throw new MofuError("The webhook signature doesn't match", 401, "bad_signature");
     return JSON.parse(rawBody);
 }
+/** Decodes verdictOf(address) → (uint8 verdict, uint8 flags, uint40 scannedAt, bytes16 fingerprint). */
+export function decodeOnchainVerdict(result, registry) {
+    const words = result.replace(/^0x/, "").match(/.{64}/g) ?? [];
+    const n = (i) => BigInt(`0x${words[i] ?? "0"}`);
+    const code = Number(n(0));
+    const f = Number(n(1));
+    const at = Number(n(2));
+    const fp = (words[3] ?? "").slice(0, 32);
+    return {
+        registry,
+        verdict: code === 1 ? "clean" : code === 2 ? "caution" : code === 3 ? "risky" : null,
+        flags: {
+            sellFailed: !!(f & 1),
+            honeypotCode: !!(f & 2),
+            canMint: !!(f & 4),
+            canPause: !!(f & 8),
+            canBlock: !!(f & 16),
+            upgradeable: !!(f & 32),
+            fakeMofu: !!(f & 64),
+        },
+        scannedAt: at ? new Date(at * 1000) : null,
+        fingerprint: /^0+$/.test(fp) || !fp ? null : fp,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mofu-sdk",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Robinhood Chain token and wallet checks for agents, bots and scripts: Mofu's Token Scanner, Wallet Health, webhooks and a buy rule.",
   "license": "MIT",
   "homepage": "https://mofu.works/docs/#sdk",