@m2msentinel/sdk 1.2.2 → 1.2.5

package/index.d.ts

@@ -14,6 +14,190 @@ export interface RecoveryChallengeOptions {
   txHash?: string;
 }
 
+export interface TransactionPreflightRequest {
+  chainId: number | string;
+  to: string;
+  data: string;
+  from?: string;
+  value?: number | string;
+  blockNumber?: number | string;
+}
+
+/** A top-level call in the documented EIP-5792 wallet_sendCalls envelope. */
+export interface WalletSendCallsCall {
+  to: string;
+  data: string;
+  /** Base Account uses canonical 0x quantities for call value. */
+  value?: string;
+  capabilities?: Record<string, Record<string, unknown>>;
+  flowControl?: Record<string, unknown>;
+}
+
+export interface WalletSendCallsParams {
+  version: '1.0';
+  id?: string;
+  from: string;
+  /** Deliberately restricted to Base's canonical wallet_sendCalls value. */
+  chainId: '0x2105';
+  atomicRequired?: boolean;
+  calls: WalletSendCallsCall[];
+  capabilities?: Record<string, Record<string, unknown>>;
+}
+
+export interface WalletSendCallsRequest {
+  method: 'wallet_sendCalls';
+  params: [WalletSendCallsParams];
+}
+
+export interface Eip1193Provider {
+  request(request: WalletSendCallsRequest): Promise<unknown>;
+}
+
+export type BaseTrustLevel = 'HIGH_TRUST_PRIMARY' | 'QUORUM_PUBLIC';
+
+export interface BaseObservationBlock {
+  status: 'PINNED';
+  chainId: number | string;
+  network: 'eip155:8453';
+  blockNumber: number | string;
+  blockHash: string;
+  blockTag: string;
+  trustLevel: BaseTrustLevel;
+  [key: string]: unknown;
+}
+
+export interface BaseSimulationObservation {
+  attempted: true;
+  trusted: true;
+  outcome: 'NOT_ATTEMPTED' | 'SUCCEEDED' | 'REVERTED' | 'UNAVAILABLE' | 'MALFORMED';
+  blockTag: string;
+  evidenceOnly: true;
+  [key: string]: unknown;
+}
+
+export interface BaseRpcObservation {
+  pinnedBlockTag: string;
+  stateBearingCallCount: number;
+  failedReadCount: 0;
+  failures: unknown[];
+  calls: BaseRpcObservationCall[];
+  [key: string]: unknown;
+}
+
+export interface BaseRpcObservationCall {
+  method?: string;
+  params?: unknown[];
+  blockTag?: string | null;
+  status?: 'OK' | 'UNSUPPORTED_OPTIONAL_METHOD' | 'EXECUTION_ERROR' | string;
+  trustLevel?: BaseTrustLevel | 'DEGRADED_LOW_TRUST';
+  [key: string]: unknown;
+}
+
+export interface BaseCapabilityEvidence {
+  sourceAddress: string;
+  executionRole: 'RESOLVED_EXECUTING_CODE' | 'SELECTED_DIAMOND_FACET';
+  transactionSelector: string | null;
+  dissection: BaseDissection;
+  notASafetyGuarantee: true;
+  reachability: 'NOT_ESTABLISHED';
+  [key: string]: unknown;
+}
+
+export interface BaseDissectionCapability {
+  type: string;
+  [key: string]: unknown;
+}
+
+export interface BaseDissection {
+  isValidContract: true;
+  bytecodeSizeBytes: number;
+  targetBytecodeHash: string;
+  capabilities: BaseDissectionCapability[];
+  detectedCapabilities: string[];
+  [key: string]: unknown;
+}
+
+export interface BaseBytecodeHashes {
+  runtimeBytecodeHash: string | null;
+  finalTargetBytecodeHash: string;
+  facetBytecodeHash: string | null;
+  facetBytecodeHashes: unknown[];
+  [key: string]: unknown;
+}
+
+export interface BaseAccountPreflightObservation {
+  status: 'SUCCESS';
+  operation: 'TRANSACTION_PREFLIGHT_OBSERVATION';
+  request: TransactionPreflightRequest;
+  selectorHex: string | null;
+  surfaceTarget: string;
+  resolvedExecutionTarget: string;
+  resolution: Record<string, unknown> & { status: 'COMPLETE'; resolutionComplete: true };
+  evidenceGrade: true;
+  evidenceStatus: 'VERIFIED';
+  effectiveTrust: BaseTrustLevel;
+  observationBlock: BaseObservationBlock;
+  simulationObservation: BaseSimulationObservation;
+  rpcObservation: BaseRpcObservation;
+  capabilityEvidence: BaseCapabilityEvidence;
+  bytecodeHashes: BaseBytecodeHashes;
+  notASafetyGuarantee: true;
+  reachability: 'NOT_ESTABLISHED';
+  limitations: string[];
+  conclusion: null;
+  [key: string]: unknown;
+}
+
+export interface BaseAccountObservationIdentity {
+  blockNumber: bigint;
+  blockTag: string;
+  blockHash: string;
+  effectiveTrust: BaseTrustLevel;
+  blockTrustLevel: BaseTrustLevel;
+  finalTargetBytecodeHash: string;
+}
+
+export interface BaseAccountGuardContext {
+  callIndex: number;
+  index: number;
+  call: WalletSendCallsCall;
+  transaction: TransactionPreflightRequest;
+  request: WalletSendCallsRequest;
+  params: WalletSendCallsParams;
+  [key: string]: unknown;
+}
+
+export type BaseAccountCallerPolicyResult =
+  | true
+  | false
+  | null
+  | undefined
+  | { allow: true; reason?: string }
+  | { allow: false; reason?: string };
+
+export type BaseAccountCallerPolicy = (
+  observation: BaseAccountPreflightObservation,
+  context: BaseAccountGuardContext
+) => BaseAccountCallerPolicyResult | Promise<BaseAccountCallerPolicyResult>;
+
+export interface GuardWalletSendCallsOptions {
+  client: Pick<M2MSentinelClient, 'preflightTransaction'>;
+  provider: Eip1193Provider;
+  request: WalletSendCallsRequest;
+  policy: BaseAccountCallerPolicy;
+  context?: Record<string, unknown>;
+}
+
+export interface BaseAccountPaymasterGuardOptions {
+  client: Pick<M2MSentinelClient, 'preflightTransaction'>;
+  policy: BaseAccountCallerPolicy;
+}
+
+export interface BaseAccountGuardCallOptions {
+  policy?: BaseAccountCallerPolicy;
+  context?: Record<string, unknown>;
+}
+
 export interface M2MSentinelErrorOptions {
   status?: number;
   body?: unknown;
@@ -56,6 +240,7 @@ export class M2MSentinelClient {
   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>;
+  preflightTransaction(transaction: TransactionPreflightRequest, options?: M2MSentinelClientOptions): Promise<any>;
   getGasFees(options?: M2MSentinelClientOptions): Promise<any>;
   getDexMetrics(options?: M2MSentinelClientOptions): Promise<any>;
   getTokenPrice(symbol: string, options?: M2MSentinelClientOptions): Promise<any>;
@@ -64,6 +249,58 @@ export class M2MSentinelClient {
   revokeKey(confirm?: boolean): Promise<any>;
 }
 
+export class WalletSendCallsInputError extends TypeError {
+  readonly code: 'INVALID_WALLET_SEND_CALLS_INPUT';
+  readonly field: string;
+  constructor(field: string, message: string);
+}
+
+export class ExecutionIdentityBlockedError extends Error {
+  readonly code: string;
+  constructor(code: string, message: string);
+}
+
+export const PreflightInputError: typeof WalletSendCallsInputError;
+export const PreflightBlockedError: typeof ExecutionIdentityBlockedError;
+
+export const BASE_CHAIN_ID: 8453;
+export const BASE_CHAIN_HEX: '0x2105';
+export const BASE_NETWORK: 'eip155:8453';
+export const MAX_CALLS: number;
+export const MAX_PREFLIGHT_CONCURRENCY: number;
+export const MAX_RPC_OBSERVATION_CALLS: number;
+export const MAX_DATA_BYTES: number;
+
+export function isAffirmativePolicyResult(value: unknown): value is true | { allow: true; reason?: string };
+export function validateWalletSendCallsRequest(request: unknown): WalletSendCallsRequest;
+export const normalizeWalletSendCallsRequest: typeof validateWalletSendCallsRequest;
+export function transactionFromCall(params: WalletSendCallsParams, call: WalletSendCallsCall, index?: number): TransactionPreflightRequest;
+export function toPreflightTransaction(params: WalletSendCallsParams, call: WalletSendCallsCall, index?: number): TransactionPreflightRequest;
+export function assertObservationReady(
+  observation: unknown,
+  transaction: TransactionPreflightRequest
+): BaseAccountObservationIdentity;
+export function guardWalletSendCalls(options: GuardWalletSendCallsOptions): Promise<unknown>;
+export const preflightWalletSendCalls: typeof guardWalletSendCalls;
+export const sendCallsWithPreflight: typeof guardWalletSendCalls;
+export const executeWalletSendCalls: typeof guardWalletSendCalls;
+
+export class BaseAccountPaymasterGuard {
+  constructor(options: BaseAccountPaymasterGuardOptions);
+  request(provider: Eip1193Provider, request: WalletSendCallsRequest, options?: BaseAccountGuardCallOptions): Promise<unknown>;
+  sendCalls(provider: Eip1193Provider, request: WalletSendCallsRequest, options?: BaseAccountGuardCallOptions): Promise<unknown>;
+}
+
+export const BaseAccountExecutionGuard: typeof BaseAccountPaymasterGuard;
+export function createBaseAccountPaymasterGuard(options: BaseAccountPaymasterGuardOptions): BaseAccountPaymasterGuard;
+export function createExecutionIdentityGuard(options: BaseAccountPaymasterGuardOptions): BaseAccountPaymasterGuard;
+export function createPublicClient(options: {
+  apiKey: string;
+  baseUrl?: string;
+  timeoutMs?: number;
+  sdk?: { M2MSentinelClient: typeof M2MSentinelClient };
+}): M2MSentinelClient;
+
 export type SentinelPolicy = (
   analysis: any,
   context: { targetAddress: string; integration: string }
@@ -110,4 +347,3 @@ export class X402SignerClient {
 export function x402SignerClient(options?: X402SignerClientOptions): X402SignerClient;
 export function parsePaymentHeader(value: string | object | null): any;
 export function parsePriceToUnits(priceStr: string | number, decimals?: number): bigint;
-

package/index.js

@@ -128,6 +128,9 @@ class M2MSentinelClient {
   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); }
+  preflightTransaction(transaction, options) {
+    return this.request('POST', '/v1/transaction/preflight', transaction, 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); }
@@ -173,6 +176,7 @@ function createViemSentinelInterceptor(apiKey, baseUrl, policy) {
 
 const { M2MSentinelActionProvider, m2mSentinelActionProvider } = require('./agent_adapter.js');
 const { X402SignerClient, x402SignerClient, parsePaymentHeader, parsePriceToUnits } = require('./x402_signer.js');
+const baseAccountPaymasterGuard = require('./base_account_paymaster_guard.js');
 
 module.exports = {
   M2MSentinelClient,
@@ -188,5 +192,6 @@ module.exports = {
   X402SignerClient,
   x402SignerClient,
   parsePaymentHeader,
-  parsePriceToUnits
+  parsePriceToUnits,
+  ...baseAccountPaymasterGuard
 };

package/mcp_server.js

@@ -8,7 +8,7 @@ const readline = require('readline');
 let BASE_URL = process.env.M2M_SENTINEL_BASE_URL || 'https://api.m2msentinel.com';
 let API_KEY = process.env.M2M_SENTINEL_API_KEY || '';
 const TIMEOUT_MS = Number(process.env.M2M_SENTINEL_TIMEOUT_MS || 30000);
-const VERSION = '1.2.2';
+const VERSION = '1.2.5';
 
 const TOOLS = [
   {
@@ -387,7 +387,7 @@ async function runCli(args) {
       console.log(`Network:         Base Mainnet (8453)`);
       console.log(`Latency:         ${res.latencyMs}ms`);
       console.log('================================================================');
-      
+
       const proxy = auditObj.proxyResolution || auditObj.proxy || {};
       const isProxy = !!proxy.isProxy;
       if (isProxy) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m2msentinel/sdk",
-  "version": "1.2.2",
+  "version": "1.2.5",
   "mcpName": "io.github.M2M-Sentinel/m2m-sentinel-sdk",
   "publishConfig": {
     "access": "public"
@@ -8,6 +8,9 @@
   "description": "JavaScript client for M2M Sentinel Base bytecode capability, proxy and market observations",
   "main": "index.js",
   "types": "index.d.ts",
+  "engines": {
+    "node": ">=18"
+  },
   "bin": {
     "m2m-sentinel-mcp": "./mcp_server.js",
     "m2m-sentinel": "./mcp_server.js",
@@ -37,12 +40,16 @@
     "glama",
     "agentkit",
     "coinbase",
-    "smart-contract-audit"
+    "smart-contract-audit",
+    "paymaster",
+    "wallet-send-calls",
+    "sponsored-transaction"
   ],
   "author": "M2M Sentinel",
   "files": [
     "index.js",
     "index.d.ts",
+    "base_account_paymaster_guard.js",
     "m2m_sentinel_sdk.js",
     "agent_adapter.js",
     "x402_signer.js",
@@ -50,7 +57,11 @@
     "mcp_server.js",
     "smithery.yaml",
     "README.md",
-    "typescript/"
+    "typescript/index.ts",
+    "typescript/x402.ts",
+    "typescript/base_account_paymaster_guard.ts",
+    "typescript/package.json",
+    "typescript/package-lock.json",
+    "typescript/tsconfig.json"
   ]
 }
-

package/typescript/base_account_paymaster_guard.ts

@@ -0,0 +1,264 @@
+import type { M2MSentinelClient, TransactionPreflightRequest } from './index';
+
+export interface WalletSendCallsCall {
+  to: string;
+  data: string;
+  /** Base Account uses canonical 0x quantities for call value. */
+  value?: string;
+  capabilities?: Record<string, Record<string, unknown>>;
+  flowControl?: Record<string, unknown>;
+}
+
+export interface WalletSendCallsParams {
+  version: '1.0';
+  id?: string;
+  from: string;
+  /** Deliberately restricted to Base's canonical wallet_sendCalls value. */
+  chainId: '0x2105';
+  atomicRequired?: boolean;
+  calls: WalletSendCallsCall[];
+  capabilities?: Record<string, Record<string, unknown>>;
+}
+
+export interface WalletSendCallsRequest {
+  method: 'wallet_sendCalls';
+  params: [WalletSendCallsParams];
+}
+
+export interface Eip1193Provider {
+  request(request: WalletSendCallsRequest): Promise<unknown>;
+}
+
+export type BaseTrustLevel = 'HIGH_TRUST_PRIMARY' | 'QUORUM_PUBLIC';
+
+export interface BaseObservationBlock {
+  status: 'PINNED';
+  chainId: number | string;
+  network: 'eip155:8453';
+  blockNumber: number | string;
+  blockHash: string;
+  blockTag: string;
+  trustLevel: BaseTrustLevel;
+  [key: string]: unknown;
+}
+
+export interface BaseSimulationObservation {
+  attempted: true;
+  trusted: true;
+  outcome: 'NOT_ATTEMPTED' | 'SUCCEEDED' | 'REVERTED' | 'UNAVAILABLE' | 'MALFORMED';
+  blockTag: string;
+  evidenceOnly: true;
+  [key: string]: unknown;
+}
+
+export interface BaseRpcObservation {
+  pinnedBlockTag: string;
+  stateBearingCallCount: number;
+  failedReadCount: 0;
+  failures: unknown[];
+  calls: BaseRpcObservationCall[];
+  [key: string]: unknown;
+}
+
+export interface BaseRpcObservationCall {
+  method?: string;
+  params?: unknown[];
+  blockTag?: string | null;
+  status?: 'OK' | 'UNSUPPORTED_OPTIONAL_METHOD' | 'EXECUTION_ERROR' | string;
+  trustLevel?: BaseTrustLevel | 'DEGRADED_LOW_TRUST';
+  [key: string]: unknown;
+}
+
+export interface BaseCapabilityEvidence {
+  sourceAddress: string;
+  executionRole: 'RESOLVED_EXECUTING_CODE' | 'SELECTED_DIAMOND_FACET';
+  transactionSelector: string | null;
+  dissection: BaseDissection;
+  notASafetyGuarantee: true;
+  reachability: 'NOT_ESTABLISHED';
+  [key: string]: unknown;
+}
+
+export interface BaseDissectionCapability {
+  type: string;
+  [key: string]: unknown;
+}
+
+export interface BaseDissection {
+  isValidContract: true;
+  bytecodeSizeBytes: number;
+  targetBytecodeHash: string;
+  capabilities: BaseDissectionCapability[];
+  detectedCapabilities: string[];
+  [key: string]: unknown;
+}
+
+export interface BaseBytecodeHashes {
+  runtimeBytecodeHash: string | null;
+  finalTargetBytecodeHash: string;
+  facetBytecodeHash: string | null;
+  facetBytecodeHashes: unknown[];
+  [key: string]: unknown;
+}
+
+export interface BaseAccountPreflightObservation {
+  status: 'SUCCESS';
+  operation: 'TRANSACTION_PREFLIGHT_OBSERVATION';
+  request: TransactionPreflightRequest;
+  selectorHex: string | null;
+  surfaceTarget: string;
+  resolvedExecutionTarget: string;
+  resolution: Record<string, unknown> & { status: 'COMPLETE'; resolutionComplete: true };
+  evidenceGrade: true;
+  evidenceStatus: 'VERIFIED';
+  effectiveTrust: BaseTrustLevel;
+  observationBlock: BaseObservationBlock;
+  simulationObservation: BaseSimulationObservation;
+  rpcObservation: BaseRpcObservation;
+  capabilityEvidence: BaseCapabilityEvidence;
+  bytecodeHashes: BaseBytecodeHashes;
+  notASafetyGuarantee: true;
+  reachability: 'NOT_ESTABLISHED';
+  limitations: string[];
+  conclusion: null;
+  [key: string]: unknown;
+}
+
+export interface BaseAccountGuardContext {
+  callIndex: number;
+  index: number;
+  call: WalletSendCallsCall;
+  transaction: TransactionPreflightRequest;
+  request: WalletSendCallsRequest;
+  params: WalletSendCallsParams;
+  [key: string]: unknown;
+}
+
+export type BaseAccountCallerPolicyResult =
+  | true
+  | false
+  | null
+  | undefined
+  | { allow: true; reason?: string }
+  | { allow: false; reason?: string };
+
+export type BaseAccountCallerPolicy = (
+  observation: BaseAccountPreflightObservation,
+  context: BaseAccountGuardContext
+) => BaseAccountCallerPolicyResult | Promise<BaseAccountCallerPolicyResult>;
+
+export interface GuardWalletSendCallsOptions {
+  client: Pick<M2MSentinelClient, 'preflightTransaction'>;
+  provider: Eip1193Provider;
+  request: WalletSendCallsRequest;
+  policy: BaseAccountCallerPolicy;
+  context?: Record<string, unknown>;
+}
+
+export interface BaseAccountPaymasterGuardOptions {
+  client: Pick<M2MSentinelClient, 'preflightTransaction'>;
+  policy: BaseAccountCallerPolicy;
+}
+
+export interface BaseAccountGuardCallOptions {
+  policy?: BaseAccountCallerPolicy;
+  context?: Record<string, unknown>;
+}
+
+export interface BaseAccountObservationIdentity {
+  blockNumber: bigint;
+  blockTag: string;
+  blockHash: string;
+  effectiveTrust: BaseTrustLevel;
+  blockTrustLevel: BaseTrustLevel;
+  finalTargetBytecodeHash: string;
+}
+
+interface WalletSendCallsInputErrorInstance extends TypeError {
+  readonly code: 'INVALID_WALLET_SEND_CALLS_INPUT';
+  readonly field: string;
+}
+
+interface ExecutionIdentityBlockedErrorInstance extends Error {
+  readonly code: string;
+}
+
+interface BaseAccountPaymasterGuardInstance {
+  request(provider: Eip1193Provider, request: WalletSendCallsRequest, options?: BaseAccountGuardCallOptions): Promise<unknown>;
+  sendCalls(provider: Eip1193Provider, request: WalletSendCallsRequest, options?: BaseAccountGuardCallOptions): Promise<unknown>;
+}
+
+// This source-distributed TypeScript entrypoint targets Node.js/CommonJS
+// (Node >=18). It intentionally loads the public runtime adapter through
+// Node's require and is not a browser-targeted bundle.
+function runtime(): any {
+  return require('../base_account_paymaster_guard.js');
+}
+
+export const BASE_CHAIN_ID: 8453 = runtime().BASE_CHAIN_ID;
+export const BASE_CHAIN_HEX: '0x2105' = runtime().BASE_CHAIN_HEX;
+export const BASE_NETWORK: 'eip155:8453' = runtime().BASE_NETWORK;
+export const MAX_CALLS: number = runtime().MAX_CALLS;
+export const MAX_PREFLIGHT_CONCURRENCY: number = runtime().MAX_PREFLIGHT_CONCURRENCY;
+export const MAX_RPC_OBSERVATION_CALLS: number = runtime().MAX_RPC_OBSERVATION_CALLS;
+export const MAX_DATA_BYTES: number = runtime().MAX_DATA_BYTES;
+
+export const WalletSendCallsInputError: {
+  new (field: string, message: string): WalletSendCallsInputErrorInstance;
+} = runtime().WalletSendCallsInputError;
+export const ExecutionIdentityBlockedError: {
+  new (code: string, message: string): ExecutionIdentityBlockedErrorInstance;
+} = runtime().ExecutionIdentityBlockedError;
+export const PreflightInputError = WalletSendCallsInputError;
+export const PreflightBlockedError = ExecutionIdentityBlockedError;
+
+export function isAffirmativePolicyResult(value: unknown): value is true | { allow: true; reason?: string } {
+  return runtime().isAffirmativePolicyResult(value);
+}
+
+export function validateWalletSendCallsRequest(request: unknown): WalletSendCallsRequest {
+  return runtime().validateWalletSendCallsRequest(request);
+}
+
+export const normalizeWalletSendCallsRequest = validateWalletSendCallsRequest;
+
+export function transactionFromCall(params: WalletSendCallsParams, call: WalletSendCallsCall, index = 0): TransactionPreflightRequest {
+  return runtime().transactionFromCall(params, call, index);
+}
+
+export const toPreflightTransaction = transactionFromCall;
+
+export function assertObservationReady(
+  observation: unknown,
+  transaction: TransactionPreflightRequest
+): BaseAccountObservationIdentity {
+  return runtime().assertObservationReady(observation, transaction);
+}
+
+export function guardWalletSendCalls(options: GuardWalletSendCallsOptions): Promise<unknown> {
+  return runtime().guardWalletSendCalls(options);
+}
+
+export const preflightWalletSendCalls = guardWalletSendCalls;
+export const sendCallsWithPreflight = guardWalletSendCalls;
+export const executeWalletSendCalls = guardWalletSendCalls;
+
+export const BaseAccountPaymasterGuard: {
+  new (options: BaseAccountPaymasterGuardOptions): BaseAccountPaymasterGuardInstance;
+} = runtime().BaseAccountPaymasterGuard;
+export const BaseAccountExecutionGuard = BaseAccountPaymasterGuard;
+
+export function createBaseAccountPaymasterGuard(options: BaseAccountPaymasterGuardOptions): BaseAccountPaymasterGuardInstance {
+  return new BaseAccountPaymasterGuard(options);
+}
+
+export const createExecutionIdentityGuard = createBaseAccountPaymasterGuard;
+
+export function createPublicClient(options: {
+  apiKey: string;
+  baseUrl?: string;
+  timeoutMs?: number;
+  sdk?: { M2MSentinelClient: typeof M2MSentinelClient };
+}): M2MSentinelClient {
+  return runtime().createPublicClient(options);
+}

package/typescript/index.ts

@@ -18,6 +18,15 @@ export interface RecoveryChallengeOptions {
   txHash?: string;
 }
 
+export interface TransactionPreflightRequest {
+  chainId: number | string;
+  to: string;
+  data: string;
+  from?: string;
+  value?: number | string;
+  blockNumber?: number | string;
+}
+
 export interface M2MSentinelErrorOptions {
   status?: number;
   body?: any;
@@ -155,6 +164,7 @@ export class M2MSentinelClient {
   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 preflightTransaction(transaction: TransactionPreflightRequest, options?: M2MSentinelClientOptions) { return this.request<any>('POST', '/v1/transaction/preflight', transaction, 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); }
@@ -216,3 +226,5 @@ export {
   X402SignerClient,
   x402SignerClient
 } from './x402';
+
+export * from './base_account_paymaster_guard';

package/typescript/package-lock.json

@@ -0,0 +1,50 @@
+{
+  "name": "m2m-sentinel-sdk",
+  "version": "1.2.5",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "m2m-sentinel-sdk",
+      "version": "1.2.5",
+      "devDependencies": {
+        "@types/node": "^22.7.5",
+        "typescript": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@types/node": {
+      "version": "22.20.1",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.20.1.tgz",
+      "integrity": "sha512-EANqOCF9QFyra+4pfxUcX9STKJpCLjMbObVzljIJomAWSnuSIEAvyzEU53GaajbXJEgdh0iEcPL+DGvpUd4k1Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.9.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "dev": true,
+      "license": "MIT"
+    }
+  }
+}