m2m-sentinel-sdk 1.2.3 → 1.2.7

package/typescript/base_account_paymaster_guard.ts

@@ -0,0 +1,284 @@
+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>;
+  preflightTransaction(transaction: TransactionPreflightRequest, options?: { policy?: BaseAccountCallerPolicy; signAndSend: (tx: any, obs: any) => Promise<unknown>; context?: Record<string, unknown> }): Promise<unknown>;
+  guardTransaction(transaction: TransactionPreflightRequest, options?: { policy?: BaseAccountCallerPolicy; signAndSend: (tx: any, obs: any) => Promise<unknown>; context?: Record<string, unknown> }): Promise<unknown>;
+}
+
+export interface PreflightBeforeSigningOptions {
+  client: Pick<M2MSentinelClient, 'preflightTransaction'>;
+  transaction: TransactionPreflightRequest;
+  policy: (
+    observation: BaseAccountPreflightObservation,
+    context: { transaction: TransactionPreflightRequest; [key: string]: unknown }
+  ) => BaseAccountCallerPolicyResult | Promise<BaseAccountCallerPolicyResult>;
+  signAndSend: (transaction: TransactionPreflightRequest, observation: BaseAccountPreflightObservation) => Promise<unknown>;
+  context?: Record<string, 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 function preflightBeforeSigning(options: PreflightBeforeSigningOptions): Promise<unknown> {
+  return runtime().preflightBeforeSigning(options);
+}
+
+export const guardTransaction = preflightBeforeSigning;
+export const preflightTransactionBeforeSigning = preflightBeforeSigning;
+
+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

@@ -226,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.7",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "m2m-sentinel-sdk",
+      "version": "1.2.7",
+      "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"
+    }
+  }
+}

package/typescript/package.json

@@ -1,14 +1,18 @@
 {
   "name": "m2m-sentinel-sdk",
-  "version": "1.2.3",
+  "version": "1.2.7",
   "description": "Source-distributed TypeScript client for M2M Sentinel Base capability intelligence API",
   "main": "index.ts",
   "types": "index.ts",
   "private": true,
+  "engines": {
+    "node": ">=18"
+  },
   "scripts": {
-    "build": "tsc"
+    "build": "tsc --noEmit"
   },
   "devDependencies": {
+    "@types/node": "^22.7.5",
     "typescript": "^5.0.0"
   }
 }

package/typescript/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "moduleResolution": "Node",
+    "lib": ["ES2020", "DOM"],
+    "types": ["node"],
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true
+  },
+  "include": ["*.ts"]
+}

package/typescript/x402.ts

@@ -318,7 +318,7 @@ export class X402SignerClient {
 
   async fetchWithAutoPayment(path: string, options: any = {}): Promise<any> {
     const url = path.startsWith('http') ? path : `${this.baseUrl}/${path.replace(/^\/+/, '')}`;
-    const headers = { 'Accept': 'application/json', 'User-Agent': '@m2msentinel/sdk-ts/1.2.3', ...(options.headers || {}) };
+    const headers = { 'Accept': 'application/json', 'User-Agent': '@m2msentinel/sdk-ts/1.2.7', ...(options.headers || {}) };
 
     let res = await fetch(url, { method: options.method || 'GET', headers, body: options.body });
     if (res.status !== 402) {

package/x402_signer.js

@@ -271,7 +271,7 @@ class X402SignerClient {
         path: url.pathname + url.search,
         method: options.method || 'GET',
         headers: {
-          'User-Agent': 'M2M-Sentinel-X402Signer/1.2.3',
+          'User-Agent': 'M2M-Sentinel-X402Signer/1.2.7',
           'Accept': 'application/json',
           ...(options.headers || {})
         },