@m2msentinel/sdk 1.1.1

package/README.md

@@ -0,0 +1,57 @@
+# M2M Sentinel SDKs
+
+Production API Base URL: `https://api.m2msentinel.com` (with fallback `https://m2msentinel.com`).
+
+M2M Sentinel reports selected static EVM bytecode capabilities, common proxy structures, evidence quality, and sourced Base market observations. Factual static capability observation — not a formal reachability audit, safety guarantee, or transaction advice. Transaction middleware therefore requires a caller-defined policy and has no built-in allow threshold.
+
+## Installation
+
+### JavaScript / TypeScript (npm)
+
+```bash
+npm install m2m-sentinel-sdk@1.1.1
+```
+
+### Python (PyPI)
+
+```bash
+pip install m2m-sentinel==1.1.0
+```
+
+### MCP Server (Model Context Protocol)
+
+```bash
+npx -y m2m-sentinel-sdk
+# or
+npx -y m2m-sentinel-mcp
+```
+
+## Authentication and x402
+
+Send API keys only in `x-api-key` (or `Authorization: Bearer`). Query-string credentials are rejected with HTTP 401. Payable routes also support x402 v2 on Base USDC. An unpaid call returns a base64 `PAYMENT-REQUIRED` challenge when the facilitator is ready; a successful settlement returns `PAYMENT-RESPONSE`.
+
+## Public Routes
+
+- `GET /v1/status`
+- `GET /v1/stats` (public privacy envelope; exact aggregate commercial counters are operator-only)
+- `GET /v1/plans`
+- `GET /v1/demo/audit/:address` for the published sample allowlist
+- `GET /v1/audit/:address` (requires API key or x402 payment)
+
+The JavaScript, TypeScript, and Python clients expose multi-period purchase/renewal and wallet recovery without requiring callers to hand-build requests:
+
+```js
+await client.createSubscriptionIntent('GROWTH', wallet, {
+  durationDays: 90,
+  renewExistingKey: true,
+  apiKey: existingPaidKey
+});
+const challenge = await client.createRecoveryChallenge(wallet, { txHash });
+await client.claimRecoveredKey(challenge.intent.id, walletSignature);
+```
+
+`getPublicStats()` returns the counter-free privacy envelope. Operator-only detail has a deliberately separate `getOperatorAggregateStats(days, token)` method and sends the operator token only as `Authorization: Bearer`. This is for private server/operator tooling only: never embed or bundle the operator token in browser, mobile, SDK-distribution, or customer code.
+
+## Disclaimer & Limitations
+
+M2M Sentinel extracts static EVM opcode capabilities and EIP-1967/UUPS proxy implementation slots on Base Mainnet. Factual static capability observation — not a formal reachability audit, safety guarantee, or transaction advice.

package/agent_adapter.js

@@ -0,0 +1,248 @@
+'use strict';
+
+/**
+ * Coinbase AgentKit Action Provider for M2M Sentinel.
+ *
+ * Exposes pre-transaction contract bytecode capability inspection, proxy resolution,
+ * and market observations to autonomous Base agents using @coinbase/agentkit.
+ */
+
+const https = require('https');
+const http = require('http');
+
+const DEFAULT_BASE_URL = process.env.M2M_SENTINEL_BASE_URL || 'https://api.m2msentinel.com';
+const DEFAULT_TIMEOUT_MS = Number(process.env.M2M_SENTINEL_TIMEOUT_MS || 30000);
+
+class M2MSentinelActionProvider {
+  constructor(options = {}) {
+    this.name = 'm2m_sentinel';
+    this.actionProviderName = 'm2m_sentinel';
+    this.baseUrl = options.baseUrl || DEFAULT_BASE_URL;
+    this.apiKey = options.apiKey || process.env.M2M_SENTINEL_API_KEY || '';
+    this.timeoutMs = Number(options.timeoutMs || DEFAULT_TIMEOUT_MS);
+  }
+
+  supportsNetwork(network) {
+    if (!network) return true;
+    const chainId = String(network.chainId || network.networkId || '');
+    const protocolFamily = String(network.protocolFamily || 'evm').toLowerCase();
+    return protocolFamily === 'evm' && (
+      chainId === '8453' ||
+      chainId === 'base' ||
+      chainId === 'base-mainnet' ||
+      chainId === 'base-sepolia' ||
+      chainId === '84532'
+    );
+  }
+
+  async _queryApi(endpointPath, options = {}) {
+    const url = new URL(endpointPath, this.baseUrl);
+    const isHttps = url.protocol === 'https:';
+    const transport = isHttps ? https : http;
+
+    const headers = {
+      Accept: 'application/json',
+      'User-Agent': 'M2MSentinel-AgentKit/1.1.1',
+      ...options.headers
+    };
+    if (this.apiKey && !headers['x-api-key']) {
+      headers['x-api-key'] = this.apiKey;
+    }
+
+    return new Promise((resolve, reject) => {
+      const req = transport.request(url, {
+        method: 'GET',
+        headers,
+        timeout: this.timeoutMs
+      }, (res) => {
+        let data = '';
+        res.setEncoding('utf8');
+        res.on('data', (chunk) => { data += chunk; });
+        res.on('end', () => {
+          let body = null;
+          if (data) {
+            try { body = JSON.parse(data); } catch (_) { body = { raw: data }; }
+          }
+          resolve({
+            statusCode: res.statusCode,
+            ok: res.statusCode >= 200 && res.statusCode < 300,
+            body
+          });
+        });
+      });
+
+      req.on('timeout', () => req.destroy(new Error('M2M Sentinel request timed out')));
+      req.on('error', reject);
+      req.end();
+    });
+  }
+
+  async auditContract(args) {
+    const address = String(args.address || args.contractAddress || '').trim();
+    if (!/^0x[0-9a-fA-F]{40}$/.test(address)) {
+      return JSON.stringify({
+        status: 'ERROR',
+        error: 'INVALID_ADDRESS',
+        message: 'A valid 40-hex 0x-prefixed Base contract address is required.'
+      });
+    }
+
+    const res = await this._queryApi(`/v1/audit/${encodeURIComponent(address)}`);
+    if (!res.ok) {
+      return JSON.stringify({
+        status: 'ERROR',
+        statusCode: res.statusCode,
+        error: res.body && res.body.error ? res.body.error : 'API_ERROR',
+        message: res.body && res.body.message ? res.body.message : 'Contract audit query failed',
+        notASafetyGuarantee: true
+      });
+    }
+
+    return JSON.stringify({
+      status: 'SUCCESS',
+      data: res.body,
+      notASafetyGuarantee: true,
+      observationSummary: `Contract ${address}: Type=${res.body.bytecodeAnalysis?.contractType || 'UNKNOWN'}, isProxy=${Boolean(res.body.proxyDetection?.isProxy)}`
+    });
+  }
+
+  async getGasMetrics() {
+    const res = await this._queryApi('/v1/gas/fees');
+    if (!res.ok) {
+      return JSON.stringify({ status: 'ERROR', statusCode: res.statusCode, message: 'Failed to retrieve gas fees' });
+    }
+    return JSON.stringify(res.body);
+  }
+
+  async getTokenPrice(args) {
+    const symbol = String(args.symbol || args.tokenSymbol || '').trim().toUpperCase();
+    if (!symbol) {
+      return JSON.stringify({ status: 'ERROR', message: 'Token symbol is required (e.g. USDC, WETH)' });
+    }
+    const res = await this._queryApi(`/v1/token/price/${encodeURIComponent(symbol)}`);
+    if (!res.ok) {
+      return JSON.stringify({ status: 'ERROR', statusCode: res.statusCode, message: `Failed to retrieve price for ${symbol}` });
+    }
+    return JSON.stringify(res.body);
+  }
+
+  async getServiceStatus() {
+    const res = await this._queryApi('/v1/status');
+    if (!res.ok) {
+      return JSON.stringify({ status: 'UNAVAILABLE', statusCode: res.statusCode });
+    }
+    return JSON.stringify(res.body);
+  }
+
+  async getDexLiquidity(args = {}) {
+    const pair = String(args.pair || 'WETH-USDC').trim();
+    const res = await this._queryApi(`/v1/dex/metrics?pair=${encodeURIComponent(pair)}`);
+    if (!res.ok) {
+      return JSON.stringify({ status: 'ERROR', statusCode: res.statusCode, message: 'Failed to retrieve DEX liquidity' });
+    }
+    return JSON.stringify(res.body);
+  }
+
+  async getWhaleSignals(args = {}) {
+    const limit = Number(args.limit || 10);
+    const res = await this._queryApi(`/v1/whales/signals?limit=${encodeURIComponent(limit)}`);
+    if (!res.ok) {
+      return JSON.stringify({ status: 'ERROR', statusCode: res.statusCode, message: 'Failed to retrieve whale signals' });
+    }
+    return JSON.stringify(res.body);
+  }
+
+  getActions(_walletProvider) {
+    return [
+      {
+        name: 'm2m_audit_contract',
+        description: 'Inspect Base target contract bytecode capability observations, proxy implementation slots, and limitations before executing transactions. Returns factual evidence, not a safety guarantee.',
+        schema: {
+          type: 'object',
+          properties: {
+            address: {
+              type: 'string',
+              description: 'Target Base contract address (0x-prefixed 40-hex)'
+            }
+          },
+          required: ['address']
+        },
+        invoke: (args) => this.auditContract(args)
+      },
+      {
+        name: 'm2m_get_gas_metrics',
+        description: 'Get real-time Base network gas execution metrics and recommendations before submitting on-chain transactions.',
+        schema: {
+          type: 'object',
+          properties: {}
+        },
+        invoke: () => this.getGasMetrics()
+      },
+      {
+        name: 'm2m_get_token_price',
+        description: 'Observe real-time Base DEX token price for slippage check and valuation.',
+        schema: {
+          type: 'object',
+          properties: {
+            symbol: {
+              type: 'string',
+              description: 'Token symbol on Base (e.g. USDC, WETH)'
+            }
+          },
+          required: ['symbol']
+        },
+        invoke: (args) => this.getTokenPrice(args)
+      },
+      {
+        name: 'm2m_get_dex_liquidity',
+        description: 'Get tracked Base DEX pool reserve and liquidity metrics.',
+        schema: {
+          type: 'object',
+          properties: {
+            pair: {
+              type: 'string',
+              description: 'DEX pair identifier (e.g. WETH-USDC)'
+            }
+          }
+        },
+        invoke: (args) => this.getDexLiquidity(args)
+      },
+      {
+        name: 'm2m_get_whale_signals',
+        description: 'Get tracked Base whale transfer and concentration signals.',
+        schema: {
+          type: 'object',
+          properties: {
+            limit: {
+              type: 'number',
+              description: 'Maximum signals to retrieve (1-50)'
+            }
+          }
+        },
+        invoke: (args) => this.getWhaleSignals(args)
+      },
+      {
+        name: 'm2m_get_service_status',
+        description: 'Check operational status of M2M Sentinel upstream verification rails.',
+        schema: {
+          type: 'object',
+          properties: {}
+        },
+        invoke: () => this.getServiceStatus()
+      }
+    ];
+  }
+}
+
+function m2mSentinelActionProvider(options = {}) {
+  return new M2MSentinelActionProvider(options);
+}
+
+// Backward compatibility alias
+class M2MSentinelAgentTool extends M2MSentinelActionProvider {}
+
+module.exports = {
+  M2MSentinelActionProvider,
+  m2mSentinelActionProvider,
+  M2MSentinelAgentTool
+};

package/eliza_plugin.js

@@ -0,0 +1,84 @@
+// UNSUPPORTED / COMMUNITY PREVIEW — not covered by the supported-SDK guarantee; verify against /openapi.json before production use.
+
+const { M2MSentinelClient } = require('./index.js');
+
+function clientFor(runtime) {
+  const apiKey = runtime?.getSetting?.('M2M_SENTINEL_API_KEY') || process.env.M2M_SENTINEL_API_KEY;
+  return new M2MSentinelClient({ apiKey });
+}
+
+function errorText(err) {
+  if (err.status === 402) return 'M2M Sentinel payment required. Configure M2M_SENTINEL_API_KEY or settle the x402 challenge.';
+  if (err.status === 503 && err.body?.error === 'DATA_SOURCE_UNAVAILABLE') return 'M2M Sentinel data source unavailable; no estimated fallback value is returned.';
+  if (err.status === 429) return 'M2M Sentinel rate limited. Retry-After: ' + (err.retryAfter || 'not provided');
+  return 'M2M Sentinel API request failed: ' + err.message;
+}
+
+const m2mSentinelPlugin = {
+  name: '@elizaos/plugin-m2m-sentinel',
+  description: 'Preview ElizaOS actions for M2M Sentinel protected Web3 API routes.',
+  actions: [
+    {
+      name: 'AUDIT_CONTRACT',
+      description: 'Reports selected static capability and proxy observations for a Base contract.',
+      handler: async (runtime, message) => {
+        const address = message.content.text.match(/0x[a-fA-F0-9]{40}/)?.[0];
+        if (!address) return { text: 'Please provide a valid 42-character EVM contract address.' };
+        try {
+          const data = await clientFor(runtime).auditContract(address);
+          const audit = data.audit || {};
+          const proxy = audit.proxyResolution || {};
+          return { text: `M2M Sentinel capability analysis for ${address}: ${audit.capabilityRating || 'UNVERIFIED'}; proxy=${proxy.isProxy ? proxy.proxyType : 'NO'}; notASafetyGuarantee=true; provenance=${JSON.stringify(audit.provenance || data.provenance || null)}` };
+        } catch (err) { return { text: errorText(err) }; }
+      }
+    },
+    {
+      name: 'GET_CAPABILITY_SCORE',
+      description: 'Returns the static capability coverage index for a Base contract. The index is not a safety score.',
+      handler: async (runtime, message) => {
+        const address = message.content.text.match(/0x[a-fA-F0-9]{40}/)?.[0];
+        if (!address) return { text: 'Please provide a valid EVM contract address.' };
+        try {
+          const data = await clientFor(runtime).getCapabilityScore(address);
+          const score = data.capabilityScore === null ? 'unverified' : `${data.capabilityScore}/100 capability coverage`;
+          return { text: `M2M Sentinel static index for ${address}: ${score}; not a safety score. Provenance: ${JSON.stringify(data.provenance || null)}` };
+        } catch (err) { return { text: errorText(err) }; }
+      }
+    },
+    {
+      name: 'GET_DEX_METRICS',
+      description: 'Fetches Base DEX metrics.',
+      handler: async (runtime) => {
+        try { return { text: JSON.stringify(await clientFor(runtime).getDexMetrics()) }; }
+        catch (err) { return { text: errorText(err) }; }
+      }
+    },
+    {
+      name: 'GET_TOKEN_PRICE',
+      description: 'Queries a tracked Base token price.',
+      handler: async (runtime, message) => {
+        const symbol = (message.content.text.match(/price of ([a-zA-Z0-9]+)/i)?.[1] || 'USDC').toUpperCase();
+        try { return { text: JSON.stringify(await clientFor(runtime).getTokenPrice(symbol)) }; }
+        catch (err) { return { text: errorText(err) }; }
+      }
+    },
+    {
+      name: 'GET_GAS_FEES',
+      description: 'Fetches live Base gas fees.',
+      handler: async (runtime) => {
+        try { return { text: JSON.stringify(await clientFor(runtime).getGasFees()) }; }
+        catch (err) { return { text: errorText(err) }; }
+      }
+    },
+    {
+      name: 'GET_WHALE_SIGNALS',
+      description: 'Fetches whale signals.',
+      handler: async (runtime) => {
+        try { return { text: JSON.stringify(await clientFor(runtime).getWhaleSignals()) }; }
+        catch (err) { return { text: errorText(err) }; }
+      }
+    }
+  ]
+};
+
+module.exports = { m2mSentinelPlugin };

package/index.d.ts

@@ -0,0 +1,94 @@
+export interface M2MSentinelClientOptions {
+  apiKey?: string;
+  baseUrl?: string;
+  timeoutMs?: number;
+  paymentSignature?: string;
+}
+
+export interface CreateSubscriptionIntentOptions extends M2MSentinelClientOptions {
+  durationDays?: 31 | 90 | 365;
+  renewExistingKey?: boolean;
+}
+
+export interface RecoveryChallengeOptions {
+  txHash?: string;
+}
+
+export interface M2MSentinelErrorOptions {
+  status?: number;
+  body?: unknown;
+  retryAfter?: string | null;
+  paymentRequired?: unknown;
+  paymentResponse?: unknown;
+}
+
+export class M2MSentinelError extends Error {
+  readonly status?: number;
+  readonly body?: unknown;
+  readonly retryAfter?: string | null;
+  readonly paymentRequired?: unknown;
+  readonly paymentResponse?: unknown;
+  constructor(message: string, options?: M2MSentinelErrorOptions);
+}
+
+export class PaymentRequiredError extends M2MSentinelError {}
+export class RateLimitedError extends M2MSentinelError {}
+export class DataSourceUnavailableError extends M2MSentinelError {}
+
+export class M2MSentinelClient {
+  constructor(options?: M2MSentinelClientOptions);
+  constructor(apiKey?: string, baseUrl?: string);
+  request(method: string, path: string, body?: unknown, options?: M2MSentinelClientOptions): Promise<any>;
+  getStatus(): Promise<any>;
+  getPublicStats(days?: number): Promise<any>;
+  /** Backward-compatible alias for getPublicStats; customer keys never reveal operator counters. */
+  getAggregateStats(days?: number): Promise<any>;
+  getOperatorAggregateStats(days: number, operatorToken: string): Promise<any>;
+  getPlans(): Promise<any>;
+  demoAudit(address: string): Promise<any>;
+  createFreeChallenge(userWallet: string): Promise<any>;
+  claimFreeTier(intentId: string, signature: string): Promise<any>;
+  createSubscriptionIntent(tier: string, userWallet: string, options?: CreateSubscriptionIntentOptions): Promise<any>;
+  claimSubscription(intentId: string, signature: string, txHash: string): Promise<any>;
+  createRecoveryChallenge(userWallet: string, options?: RecoveryChallengeOptions): Promise<any>;
+  claimRecoveredKey(intentId: string, signature: string): Promise<any>;
+  auditContract(address: string, options?: M2MSentinelClientOptions): Promise<any>;
+  getCapabilityScore(address: string, options?: M2MSentinelClientOptions): Promise<any>;
+  /** Legacy alias. The response is a capability coverage index, not a safety score. */
+  getSecurityScore(address: string, options?: M2MSentinelClientOptions): Promise<any>;
+  getGasFees(options?: M2MSentinelClientOptions): Promise<any>;
+  getDexMetrics(options?: M2MSentinelClientOptions): Promise<any>;
+  getTokenPrice(symbol: string, options?: M2MSentinelClientOptions): Promise<any>;
+  getWhaleSignals(options?: M2MSentinelClientOptions): Promise<any>;
+  getKeySelf(): Promise<any>;
+  revokeKey(confirm?: boolean): Promise<any>;
+}
+
+export type SentinelPolicy = (
+  analysis: any,
+  context: { targetAddress: string; integration: string }
+) => boolean | { allow: boolean; reason?: string } | Promise<boolean | { allow: boolean; reason?: string }>;
+
+export function enforceCallerPolicy(
+  policy: SentinelPolicy | undefined,
+  analysis: any,
+  context: { targetAddress: string; integration: string }
+): Promise<void>;
+
+export function createEthersSentinelMiddleware(
+  apiKey?: string,
+  baseUrl?: string,
+  policy?: SentinelPolicy
+): {
+  client: M2MSentinelClient;
+  verifyContractBeforeTx(targetAddress: string, policyOverride?: SentinelPolicy): Promise<any>;
+};
+
+export function createViemSentinelInterceptor(
+  apiKey?: string,
+  baseUrl?: string,
+  policy?: SentinelPolicy
+): {
+  client: M2MSentinelClient;
+  inspectSwapTarget(address: string, policyOverride?: SentinelPolicy): Promise<any>;
+};

package/index.js

@@ -0,0 +1,187 @@
+const DEFAULT_BASE_URL = 'https://api.m2msentinel.com';
+const DEFAULT_TIMEOUT_MS = 30000;
+
+class M2MSentinelError extends Error {
+  constructor(message, options = {}) {
+    super(message);
+    this.name = this.constructor.name;
+    this.status = options.status;
+    this.body = options.body;
+    this.retryAfter = options.retryAfter || null;
+    this.paymentRequired = options.paymentRequired || null;
+    this.paymentResponse = options.paymentResponse || null;
+  }
+}
+
+class PaymentRequiredError extends M2MSentinelError {}
+class RateLimitedError extends M2MSentinelError {}
+class DataSourceUnavailableError extends M2MSentinelError {}
+
+function parseX402Header(value) {
+  if (!value) return null;
+  // x402 v2 transports protocol objects as base64 JSON. Retain raw-JSON
+  // compatibility for older M2M Sentinel deployments during upgrades.
+  try { return JSON.parse(value); } catch (_) { /* try v2 encoding */ }
+  try {
+    const normalized = String(value).replace(/-/g, '+').replace(/_/g, '/');
+    const padded = normalized + '='.repeat((4 - normalized.length % 4) % 4);
+    return JSON.parse(Buffer.from(padded, 'base64').toString('utf8'));
+  } catch (_) {
+    return null;
+  }
+}
+
+function normalizeOptions(optionsOrApiKey, baseUrl) {
+  if (optionsOrApiKey && typeof optionsOrApiKey === 'object') return { ...optionsOrApiKey };
+  return { apiKey: optionsOrApiKey || undefined, baseUrl: baseUrl || DEFAULT_BASE_URL };
+}
+
+class M2MSentinelClient {
+  constructor(optionsOrApiKey, baseUrl) {
+    const options = normalizeOptions(optionsOrApiKey, baseUrl);
+    this.baseUrl = (options.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, '');
+    this.apiKey = options.apiKey || undefined;
+    this.timeoutMs = options.timeoutMs || DEFAULT_TIMEOUT_MS;
+    this.paymentSignature = options.paymentSignature || undefined;
+  }
+
+  async request(method, path, body, options = {}) {
+    const headers = {
+      'Accept': 'application/json'
+    };
+    if (body !== undefined) headers['Content-Type'] = 'application/json';
+    const apiKey = options.apiKey || this.apiKey;
+    if (apiKey) headers['x-api-key'] = apiKey;
+    if (options.operatorToken) headers.Authorization = 'Bearer ' + options.operatorToken;
+    const paymentSignature = options.paymentSignature || this.paymentSignature;
+    if (paymentSignature) headers['PAYMENT-SIGNATURE'] = paymentSignature;
+
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), options.timeoutMs || this.timeoutMs);
+    let response;
+    try {
+      response = await fetch(this.baseUrl + path, {
+        method,
+        headers,
+        body: body === undefined ? undefined : JSON.stringify(body),
+        signal: controller.signal
+      });
+    } catch (err) {
+      if (err && err.name === 'AbortError') throw new M2MSentinelError('M2M Sentinel request timed out', { status: 0 });
+      throw err;
+    } finally {
+      clearTimeout(timeout);
+    }
+
+    const text = await response.text();
+    let data = null;
+    if (text) {
+      try { data = JSON.parse(text); } catch (_) { data = { raw: text }; }
+    }
+
+    const paymentRequired = parseX402Header(response.headers.get('PAYMENT-REQUIRED'));
+    const paymentResponse = parseX402Header(response.headers.get('PAYMENT-RESPONSE')) || response.headers.get('PAYMENT-RESPONSE');
+    if (response.ok) return data;
+
+    const details = {
+      status: response.status,
+      body: data,
+      retryAfter: response.headers.get('Retry-After'),
+      paymentRequired,
+      paymentResponse
+    };
+    const message = data && data.message ? data.message : 'M2M Sentinel HTTP ' + response.status;
+    if (response.status === 402) throw new PaymentRequiredError(message, details);
+    if (response.status === 429) throw new RateLimitedError(message, details);
+    if (response.status === 503 && data && data.error === 'DATA_SOURCE_UNAVAILABLE') throw new DataSourceUnavailableError(message, details);
+    throw new M2MSentinelError(message, details);
+  }
+
+  getStatus() { return this.request('GET', '/v1/status'); }
+  getPublicStats(days = 30) { return this.request('GET', '/v1/stats?days=' + encodeURIComponent(days)); }
+  // Backward-compatible alias. Ordinary/customer credentials still receive
+  // only the counter-free public privacy envelope.
+  getAggregateStats(days = 30) { return this.getPublicStats(days); }
+  getOperatorAggregateStats(days, operatorToken) {
+    return this.request('GET', '/v1/stats?days=' + encodeURIComponent(days || 30), undefined, { operatorToken });
+  }
+  getPlans() { return this.request('GET', '/v1/plans'); }
+  demoAudit(address) { return this.request('GET', '/v1/demo/audit/' + encodeURIComponent(address)); }
+  createFreeChallenge(userWallet) { return this.request('POST', '/v1/subscribe/free/challenge', { userWallet }); }
+  claimFreeTier(intentId, signature) { return this.request('POST', '/v1/subscribe/free/claim', { intentId, signature }); }
+  createSubscriptionIntent(tier, userWallet, options = {}) {
+    const body = { tier, userWallet };
+    if (options.durationDays !== undefined) body.durationDays = options.durationDays;
+    if (options.renewExistingKey !== undefined) body.renewExistingKey = options.renewExistingKey;
+    return this.request('POST', '/v1/subscribe/intents', body, options);
+  }
+  claimSubscription(intentId, signature, txHash) { return this.request('POST', '/v1/subscribe/crypto', { intentId, signature, txHash }); }
+  createRecoveryChallenge(userWallet, options = {}) {
+    const body = { userWallet };
+    if (options.txHash !== undefined) body.txHash = options.txHash;
+    return this.request('POST', '/v1/keys/recovery/challenge', body);
+  }
+  claimRecoveredKey(intentId, signature) {
+    return this.request('POST', '/v1/keys/recovery/claim', { intentId, signature });
+  }
+  auditContract(address, options) { return this.request('GET', '/v1/audit/' + encodeURIComponent(address), undefined, options); }
+  getCapabilityScore(address, options) { return this.request('GET', '/v1/security/score/' + encodeURIComponent(address), undefined, options); }
+  // Legacy method name; the response is a capability coverage index, not a safety score.
+  getSecurityScore(address, options) { return this.request('GET', '/v1/security/score/' + encodeURIComponent(address), undefined, options); }
+  getGasFees(options) { return this.request('GET', '/v1/gas/fees', undefined, options); }
+  getDexMetrics(options) { return this.request('GET', '/v1/dex/metrics', undefined, options); }
+  getTokenPrice(symbol, options) { return this.request('GET', '/v1/token/price/' + encodeURIComponent(symbol), undefined, options); }
+  getWhaleSignals(options) { return this.request('GET', '/v1/whales/signals', undefined, options); }
+  getKeySelf() { return this.request('GET', '/v1/keys/self'); }
+  revokeKey(confirm = true) { return this.request('POST', '/v1/keys/revoke', { confirm }); }
+}
+
+async function enforceCallerPolicy(policy, analysis, context) {
+  if (typeof policy !== 'function') {
+    throw new Error('[M2M Sentinel] A caller-defined policy function is required. Static capability observations are not a safety decision.');
+  }
+  const result = await policy(analysis, context);
+  if (result === false || (result && result.allow === false)) {
+    const reason = result && result.reason ? result.reason : 'caller-defined policy rejected the transaction';
+    throw new Error('[M2M Sentinel] Transaction blocked: ' + reason + '.');
+  }
+}
+
+function createEthersSentinelMiddleware(apiKey, baseUrl, policy) {
+  const client = new M2MSentinelClient({ apiKey, baseUrl });
+  return {
+    client,
+    verifyContractBeforeTx: async (targetAddress, policyOverride) => {
+      const audit = await client.auditContract(targetAddress);
+      await enforceCallerPolicy(policyOverride || policy, audit, { targetAddress, integration: 'ethers' });
+      return audit;
+    }
+  };
+}
+
+function createViemSentinelInterceptor(apiKey, baseUrl, policy) {
+  const client = new M2MSentinelClient({ apiKey, baseUrl });
+  return {
+    client,
+    inspectSwapTarget: async (address, policyOverride) => {
+      const analysis = await client.getCapabilityScore(address);
+      await enforceCallerPolicy(policyOverride || policy, analysis, { targetAddress: address, integration: 'viem' });
+      return analysis;
+    }
+  };
+}
+
+const { M2MSentinelActionProvider, m2mSentinelActionProvider } = require('./agent_adapter.js');
+
+module.exports = {
+  M2MSentinelClient,
+  M2MSentinelError,
+  PaymentRequiredError,
+  RateLimitedError,
+  DataSourceUnavailableError,
+  enforceCallerPolicy,
+  createEthersSentinelMiddleware,
+  createViemSentinelInterceptor,
+  M2MSentinelActionProvider,
+  m2mSentinelActionProvider
+};

package/m2m_sentinel_sdk.js

@@ -0,0 +1 @@
+module.exports = require('./index.js');

package/mcp_server.js

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+'use strict';
+
+const https = require('https');
+const http = require('http');
+const readline = require('readline');
+
+const BASE_URL = process.env.M2M_SENTINEL_BASE_URL || 'https://api.m2msentinel.com';
+const API_KEY = process.env.M2M_SENTINEL_API_KEY || '';
+const TIMEOUT_MS = Number(process.env.M2M_SENTINEL_TIMEOUT_MS || 30000);
+
+const TOOLS = [
+  {
+    name: 'm2m_audit_contract',
+    description: 'Return selected static bytecode capability observations, common proxy resolution, limitations, and provenance for a Base contract. This is factual capability observation, not a safety or exploitability guarantee.',
+    inputSchema: { type: 'object', properties: { address: { type: 'string', description: 'Base contract address (0x...)' } }, required: ['address'] }
+  },
+  {
+    name: 'm2m_get_gas_metrics',
+    description: 'Return sourced Base gas fee metrics and execution recommendations.',
+    inputSchema: { type: 'object', properties: {} }
+  },
+  {
+    name: 'm2m_get_token_price',
+    description: 'Return sourced Base DEX token price observation for allowlisted assets (e.g. USDC, WETH).',
+    inputSchema: { type: 'object', properties: { symbol: { type: 'string', description: 'Token symbol (USDC, WETH)' } }, required: ['symbol'] }
+  },
+  {
+    name: 'm2m_get_dex_liquidity',
+    description: 'Return tracked Base DEX pool reserve and liquidity metrics.',
+    inputSchema: { type: 'object', properties: { pair: { type: 'string' } } }
+  },
+  {
+    name: 'm2m_get_whale_signals',
+    description: 'Return tracked Base whale transfer signals.',
+    inputSchema: { type: 'object', properties: { limit: { type: 'number' } } }
+  },
+  {
+    name: 'm2m_get_service_status',
+    description: 'Return real-time operational status of M2M Sentinel upstream RPC and persistence rails.',
+    inputSchema: { type: 'object', properties: {} }
+  },
+  // Backwards compatibility aliases
+  {
+    name: 'audit_contract',
+    description: 'Alias for m2m_audit_contract.',
+    inputSchema: { type: 'object', properties: { address: { type: 'string' } }, required: ['address'] }
+  },
+  {
+    name: 'get_capability_score',
+    description: 'Return the static capability coverage index and provenance for a Base contract. This is not a safety score.',
+    inputSchema: { type: 'object', properties: { address: { type: 'string' } }, required: ['address'] }
+  },
+  {
+    name: 'get_gas_fees',
+    description: 'Alias for m2m_get_gas_metrics.',
+    inputSchema: { type: 'object', properties: {} }
+  },
+  {
+    name: 'get_dex_metrics',
+    description: 'Alias for m2m_get_dex_liquidity.',
+    inputSchema: { type: 'object', properties: {} }
+  },
+  {
+    name: 'get_token_price',
+    description: 'Alias for m2m_get_token_price.',
+    inputSchema: { type: 'object', properties: { symbol: { type: 'string' } }, required: ['symbol'] }
+  },
+  {
+    name: 'get_whale_signals',
+    description: 'Alias for m2m_get_whale_signals.',
+    inputSchema: { type: 'object', properties: {} }
+  }
+];
+
+function parseX402Header(value) {
+  if (!value) return null;
+  try { return JSON.parse(value); } catch (_) {}
+  try {
+    const normalized = String(value).replace(/-/g, '+').replace(/_/g, '/');
+    const padded = normalized + '='.repeat((4 - normalized.length % 4) % 4);
+    return JSON.parse(Buffer.from(padded, 'base64').toString('utf8'));
+  } catch (_) {
+    return null;
+  }
+}
+
+function queryApi(path) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(path, BASE_URL);
+    const isHttps = url.protocol === 'https:';
+    const transport = isHttps ? https : http;
+    const headers = { Accept: 'application/json', 'User-Agent': 'M2MSentinel-MCP/1.1.0' };
+    if (API_KEY) headers['x-api-key'] = API_KEY;
+
+    const req = transport.request(url, { method: 'GET', headers, timeout: TIMEOUT_MS }, (res) => {
+      let data = '';
+      res.setEncoding('utf8');
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        let body = null;
+        if (data) {
+          try { body = JSON.parse(data); } catch (_) { body = { raw: data }; }
+        }
+        resolve({
+          status: res.statusCode,
+          ok: res.statusCode >= 200 && res.statusCode < 300,
+          body,
+          paymentRequired: parseX402Header(res.headers['payment-required'] || res.headers['x-payment-required']),
+          paymentResponse: parseX402Header(res.headers['payment-response'] || res.headers['x-payment-response']),
+          retryAfter: res.headers['retry-after'] || null
+        });
+      });
+    });
+    req.on('timeout', () => req.destroy(new Error('M2M Sentinel request timed out')));
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+function pathForTool(name, args) {
+  const input = args || {};
+  switch (name) {
+    case 'm2m_audit_contract':
+    case 'audit_contract':
+      if (!input.address) throw new Error('address is required');
+      return '/v1/audit/' + encodeURIComponent(input.address);
+    case 'get_capability_score':
+      if (!input.address) throw new Error('address is required');
+      return '/v1/security/score/' + encodeURIComponent(input.address);
+    case 'm2m_get_gas_metrics':
+    case 'get_gas_fees':
+      return '/v1/gas/fees';
+    case 'm2m_get_dex_liquidity':
+    case 'get_dex_metrics':
+      return '/v1/dex/metrics';
+    case 'm2m_get_token_price':
+    case 'get_token_price':
+      if (!input.symbol) throw new Error('symbol is required');
+      return '/v1/token/price/' + encodeURIComponent(input.symbol);
+    case 'm2m_get_whale_signals':
+    case 'get_whale_signals':
+      return '/v1/whales/signals';
+    case 'm2m_get_service_status':
+      return '/v1/status';
+    default:
+      throw new Error('Unknown tool: ' + name);
+  }
+}
+
+function send(message) {
+  process.stdout.write(JSON.stringify(message) + '\n');
+}
+
+function success(id, result) {
+  send({ jsonrpc: '2.0', id, result });
+}
+
+function failure(id, code, message, data) {
+  const error = { code, message };
+  if (data !== undefined) error.data = data;
+  send({ jsonrpc: '2.0', id, error });
+}
+
+async function handle(request) {
+  if (!request || request.jsonrpc !== '2.0' || typeof request.method !== 'string') {
+    failure(request && request.id !== undefined ? request.id : null, -32600, 'Invalid Request');
+    return;
+  }
+  if (request.id === undefined || request.id === null) return;
+
+  try {
+    if (request.method === 'initialize') {
+      success(request.id, {
+        protocolVersion: request.params && request.params.protocolVersion ? request.params.protocolVersion : '2024-11-05',
+        capabilities: { tools: {} },
+        serverInfo: { name: 'm2m-sentinel-mcp', version: '1.1.0' }
+      });
+      return;
+    }
+    if (request.method === 'tools/list') {
+      success(request.id, { tools: TOOLS });
+      return;
+    }
+    if (request.method === 'tools/call') {
+      const params = request.params || {};
+      const path = pathForTool(params.name, params.arguments || {});
+      const apiResult = await queryApi(path);
+      const isError = !apiResult.ok;
+      success(request.id, {
+        content: [{ type: 'text', text: typeof apiResult.body === 'object' ? JSON.stringify(apiResult.body, null, 2) : String(apiResult.body) }],
+        isError,
+        structuredContent: apiResult.body,
+        _meta: {
+          httpStatus: apiResult.status,
+          paymentRequired: apiResult.paymentRequired,
+          paymentResponse: apiResult.paymentResponse,
+          retryAfter: apiResult.retryAfter,
+          notASafetyGuarantee: true
+        }
+      });
+      return;
+    }
+    failure(request.id, -32601, 'Method not found');
+  } catch (err) {
+    failure(request.id, -32603, err && err.message ? err.message : 'Internal error');
+  }
+}
+
+const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+rl.on('line', (line) => {
+  if (!line.trim()) return;
+  let request;
+  try {
+    request = JSON.parse(line);
+  } catch (_) {
+    failure(null, -32700, 'Parse error');
+    return;
+  }
+  handle(request);
+});
+
+module.exports = { TOOLS, pathForTool, parseX402Header };

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@m2msentinel/sdk",
+  "version": "1.1.1",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "JavaScript client for M2M Sentinel Base bytecode capability, proxy and market observations",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "bin": {
+    "m2m-sentinel-mcp": "./mcp_server.js",
+    "m2m-sentinel": "./mcp_server.js"
+  },
+  "license": "MIT",
+  "homepage": "https://m2msentinel.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/M2M-Sentinel/m2m-sentinel-sdk.git"
+  },
+  "bugs": {
+    "url": "https://m2msentinel.com/docs.html"
+  },
+  "keywords": [
+    "web3",
+    "x402",
+    "m2m-sentinel",
+    "base",
+    "bytecode-capabilities",
+    "proxy-detection",
+    "agents",
+    "mcp",
+    "model-context-protocol",
+    "mcp-server",
+    "smithery",
+    "glama",
+    "agentkit",
+    "coinbase",
+    "smart-contract-audit"
+  ],
+  "author": "M2M Sentinel",
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "m2m_sentinel_sdk.js",
+    "agent_adapter.js",
+    "eliza_plugin.js",
+    "mcp_server.js",
+    "smithery.yaml",
+    "README.md",
+    "typescript/"
+  ]
+}
+

package/smithery.yaml

@@ -0,0 +1,27 @@
+# Smithery MCP Server Configuration
+# https://smithery.ai/docs/config
+
+startCommand:
+  type: stdio
+  command: npx
+  args:
+    - -y
+    - m2m-sentinel-sdk
+  configSchema:
+    type: object
+    properties:
+      M2M_SENTINEL_API_KEY:
+        type: string
+        title: M2M Sentinel API Key
+        description: Optional API key for higher rate limits. Public free tier works without key.
+        default: ""
+
+configSchema:
+  type: object
+  properties:
+    M2M_SENTINEL_API_KEY:
+      type: string
+      title: M2M Sentinel API Key
+      description: Optional API key for higher rate limits. Public free tier works without key.
+      default: ""
+

package/typescript/index.ts

@@ -0,0 +1,204 @@
+export interface M2MSentinelClientOptions {
+  apiKey?: string;
+  baseUrl?: string;
+  timeoutMs?: number;
+  paymentSignature?: string;
+}
+
+interface M2MSentinelRequestOptions extends M2MSentinelClientOptions {
+  operatorToken?: string;
+}
+
+export interface CreateSubscriptionIntentOptions extends M2MSentinelClientOptions {
+  durationDays?: 31 | 90 | 365;
+  renewExistingKey?: boolean;
+}
+
+export interface RecoveryChallengeOptions {
+  txHash?: string;
+}
+
+export interface M2MSentinelErrorOptions {
+  status?: number;
+  body?: any;
+  retryAfter?: string | null;
+  paymentRequired?: any;
+  paymentResponse?: any;
+}
+
+export class M2MSentinelError extends Error {
+  public readonly status?: number;
+  public readonly body?: any;
+  public readonly retryAfter?: string | null;
+  public readonly paymentRequired?: any;
+  public readonly paymentResponse?: any;
+
+  constructor(message: string, options: M2MSentinelErrorOptions = {}) {
+    super(message);
+    this.name = new.target.name;
+    this.status = options.status;
+    this.body = options.body;
+    this.retryAfter = options.retryAfter || null;
+    this.paymentRequired = options.paymentRequired || null;
+    this.paymentResponse = options.paymentResponse || null;
+  }
+}
+
+export class PaymentRequiredError extends M2MSentinelError {}
+export class RateLimitedError extends M2MSentinelError {}
+export class DataSourceUnavailableError extends M2MSentinelError {}
+
+const DEFAULT_BASE_URL = 'https://api.m2msentinel.com';
+const DEFAULT_TIMEOUT_MS = 30000;
+
+function parseX402Header(value: string | null): any {
+  if (!value) return null;
+  try { return JSON.parse(value); } catch { /* try v2 encoding */ }
+  try {
+    const normalized = value.replace(/-/g, '+').replace(/_/g, '/');
+    const padded = normalized + '='.repeat((4 - normalized.length % 4) % 4);
+    const bytes = Uint8Array.from(atob(padded), (character) => character.charCodeAt(0));
+    return JSON.parse(new TextDecoder().decode(bytes));
+  } catch {
+    return null;
+  }
+}
+
+export class M2MSentinelClient {
+  private baseUrl: string;
+  private apiKey?: string;
+  private timeoutMs: number;
+  private paymentSignature?: string;
+
+  constructor(optionsOrBaseUrl: M2MSentinelClientOptions | string = {}, apiKey?: string) {
+    const options = typeof optionsOrBaseUrl === 'string'
+      ? { baseUrl: optionsOrBaseUrl, apiKey }
+      : optionsOrBaseUrl;
+    this.baseUrl = (options.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, '');
+    this.apiKey = options.apiKey;
+    this.timeoutMs = options.timeoutMs || DEFAULT_TIMEOUT_MS;
+    this.paymentSignature = options.paymentSignature;
+  }
+
+  private async request<T>(method: 'GET' | 'POST', path: string, body?: any, options: M2MSentinelRequestOptions = {}): Promise<T> {
+    const headers: Record<string, string> = {
+      Accept: 'application/json'
+    };
+    if (body !== undefined) headers['Content-Type'] = 'application/json';
+    const key = options.apiKey || this.apiKey;
+    if (key) headers['x-api-key'] = key;
+    if (options.operatorToken) headers.Authorization = `Bearer ${options.operatorToken}`;
+    const paymentSignature = options.paymentSignature || this.paymentSignature;
+    if (paymentSignature) headers['PAYMENT-SIGNATURE'] = paymentSignature;
+
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), options.timeoutMs || this.timeoutMs);
+    let response: Response;
+    try {
+      response = await fetch(this.baseUrl + path, {
+        method,
+        headers,
+        body: body === undefined ? undefined : JSON.stringify(body),
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(timeout);
+    }
+
+    const text = await response.text();
+    let data: any = null;
+    if (text) {
+      try { data = JSON.parse(text); } catch { data = { raw: text }; }
+    }
+    if (response.ok) return data as T;
+
+    const errorOptions = {
+      status: response.status,
+      body: data,
+      retryAfter: response.headers.get('Retry-After'),
+      paymentRequired: parseX402Header(response.headers.get('PAYMENT-REQUIRED')),
+      paymentResponse: parseX402Header(response.headers.get('PAYMENT-RESPONSE')) || response.headers.get('PAYMENT-RESPONSE')
+    };
+    const message = data?.message || `M2M Sentinel HTTP ${response.status}`;
+    if (response.status === 402) throw new PaymentRequiredError(message, errorOptions);
+    if (response.status === 429) throw new RateLimitedError(message, errorOptions);
+    if (response.status === 503 && data?.error === 'DATA_SOURCE_UNAVAILABLE') throw new DataSourceUnavailableError(message, errorOptions);
+    throw new M2MSentinelError(message, errorOptions);
+  }
+
+  public getStatus() { return this.request<any>('GET', '/v1/status'); }
+  public getPublicStats(days = 30) { return this.request<any>('GET', `/v1/stats?days=${encodeURIComponent(days)}`); }
+  public getAggregateStats(days = 30) { return this.getPublicStats(days); }
+  public getOperatorAggregateStats(days: number, operatorToken: string) {
+    return this.request<any>('GET', `/v1/stats?days=${encodeURIComponent(days || 30)}`, undefined, { operatorToken });
+  }
+  public getPlans() { return this.request<any>('GET', '/v1/plans'); }
+  public demoAudit(address: string) { return this.request<any>('GET', `/v1/demo/audit/${encodeURIComponent(address)}`); }
+  public createFreeChallenge(userWallet: string) { return this.request<any>('POST', '/v1/subscribe/free/challenge', { userWallet }); }
+  public claimFreeTier(intentId: string, signature: string) { return this.request<any>('POST', '/v1/subscribe/free/claim', { intentId, signature }); }
+  public createSubscriptionIntent(tier: string, userWallet: string, options: CreateSubscriptionIntentOptions = {}) {
+    const body: Record<string, any> = { tier, userWallet };
+    if (options.durationDays !== undefined) body.durationDays = options.durationDays;
+    if (options.renewExistingKey !== undefined) body.renewExistingKey = options.renewExistingKey;
+    return this.request<any>('POST', '/v1/subscribe/intents', body, options);
+  }
+  public claimSubscription(intentId: string, signature: string, txHash: string) { return this.request<any>('POST', '/v1/subscribe/crypto', { intentId, signature, txHash }); }
+  public createRecoveryChallenge(userWallet: string, options: RecoveryChallengeOptions = {}) {
+    const body: Record<string, string> = { userWallet };
+    if (options.txHash !== undefined) body.txHash = options.txHash;
+    return this.request<any>('POST', '/v1/keys/recovery/challenge', body);
+  }
+  public claimRecoveredKey(intentId: string, signature: string) {
+    return this.request<any>('POST', '/v1/keys/recovery/claim', { intentId, signature });
+  }
+  public auditContract(address: string, options?: M2MSentinelClientOptions) { return this.request<any>('GET', `/v1/audit/${encodeURIComponent(address)}`, undefined, options); }
+  public getCapabilityScore(address: string, options?: M2MSentinelClientOptions) { return this.request<any>('GET', `/v1/security/score/${encodeURIComponent(address)}`, undefined, options); }
+  /** Legacy name. The response is a capability coverage index, not a safety score. */
+  public getSecurityScore(address: string, options?: M2MSentinelClientOptions) { return this.request<any>('GET', `/v1/security/score/${encodeURIComponent(address)}`, undefined, options); }
+  public getGasFees(options?: M2MSentinelClientOptions) { return this.request<any>('GET', '/v1/gas/fees', undefined, options); }
+  public getDexMetrics(options?: M2MSentinelClientOptions) { return this.request<any>('GET', '/v1/dex/metrics', undefined, options); }
+  public getTokenPrice(symbol: string, options?: M2MSentinelClientOptions) { return this.request<any>('GET', `/v1/token/price/${encodeURIComponent(symbol)}`, undefined, options); }
+  public getWhaleSignals(options?: M2MSentinelClientOptions) { return this.request<any>('GET', '/v1/whales/signals', undefined, options); }
+  public getKeySelf() { return this.request<any>('GET', '/v1/keys/self'); }
+  public revokeKey(confirm = true) { return this.request<any>('POST', '/v1/keys/revoke', { confirm }); }
+}
+
+export type SentinelPolicy = (analysis: any, context: { targetAddress: string; integration: string }) =>
+  boolean | { allow: boolean; reason?: string } | Promise<boolean | { allow: boolean; reason?: string }>;
+
+export async function enforceCallerPolicy(policy: SentinelPolicy | undefined, analysis: any, context: { targetAddress: string; integration: string }) {
+  if (typeof policy !== 'function') {
+    throw new Error('[M2M Sentinel] A caller-defined policy function is required. Static capability observations are not a safety decision.');
+  }
+  const result = await policy(analysis, context);
+  if (result === false || (typeof result === 'object' && result !== null && result.allow === false)) {
+    const reason = typeof result === 'object' && result !== null && result.reason
+      ? result.reason
+      : 'caller-defined policy rejected the transaction';
+    throw new Error(`[M2M Sentinel] Transaction blocked: ${reason}.`);
+  }
+}
+
+export function createEthersSentinelMiddleware(apiKey?: string, baseUrl?: string, policy?: SentinelPolicy) {
+  const client = new M2MSentinelClient({ apiKey, baseUrl });
+  return {
+    client,
+    verifyContractBeforeTx: async (targetAddress: string, policyOverride?: SentinelPolicy) => {
+      const audit = await client.auditContract(targetAddress);
+      await enforceCallerPolicy(policyOverride || policy, audit, { targetAddress, integration: 'ethers' });
+      return audit;
+    }
+  };
+}
+
+export function createViemSentinelInterceptor(apiKey?: string, baseUrl?: string, policy?: SentinelPolicy) {
+  const client = new M2MSentinelClient({ apiKey, baseUrl });
+  return {
+    client,
+    inspectSwapTarget: async (address: string, policyOverride?: SentinelPolicy) => {
+      const analysis = await client.getCapabilityScore(address);
+      await enforceCallerPolicy(policyOverride || policy, analysis, { targetAddress: address, integration: 'viem' });
+      return analysis;
+    }
+  };
+}

package/typescript/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "m2m-sentinel-sdk",
+  "version": "1.1.0",
+  "description": "Source-distributed TypeScript client for M2M Sentinel Base capability intelligence API",
+  "main": "index.ts",
+  "types": "index.ts",
+  "private": true,
+  "scripts": {
+    "build": "tsc"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  }
+}