@scriptmasterlabs/mcp-x402 2.0.2 → 2.1.1

package/src/lib/sml-api/agentcard.ts

@@ -1,40 +0,0 @@
-const AGENTCARD_BASE = process.env['AGENTCARD_URL'] ?? 'https://agentcard.onrender.com';
-
-async function acGet(path: string): Promise<unknown> {
-  const res = await fetch(`${AGENTCARD_BASE}${path}`, {
-    headers: { 'Accept': 'application/json' },
-    signal: AbortSignal.timeout(10_000),
-  });
-  if (!res.ok) throw new Error(`AgentCard GET ${path}: HTTP ${res.status}`);
-  return res.json();
-}
-
-export interface AgentCardMintParams {
-  walletAddress: string;
-  name: string;
-  did?: string;
-  metadata?: Record<string, unknown>;
-}
-
-export interface AgentCardVerifyParams {
-  walletAddress: string;
-  message: string;
-  signature: string;
-}
-
-async function acPost(path: string, body: unknown): Promise<unknown> {
-  const res = await fetch(`${AGENTCARD_BASE}${path}`, {
-    method: 'POST',
-    headers: { 'Accept': 'application/json', 'Content-Type': 'application/json' },
-    body: JSON.stringify(body),
-    signal: AbortSignal.timeout(15_000),
-  });
-  if (!res.ok) throw new Error(`AgentCard POST ${path}: HTTP ${res.status}`);
-  return res.json();
-}
-
-export const AgentCardAPI = {
-  lookup: (walletOrDid: string) => acGet(`/v1/card/${encodeURIComponent(walletOrDid)}`),
-  verify: (params: AgentCardVerifyParams) => acPost('/v1/verify', params),
-  mint: (params: AgentCardMintParams) => acPost('/v1/mint', params),
-};

package/src/lib/sml-api/backtest.ts

@@ -1,47 +0,0 @@
-// backtester-mcp microservice client
-// Wraps the Python backtest_service.py running at BACKTEST_BASE_URL
-
-const BASE = process.env.BACKTEST_BASE_URL ?? 'http://localhost:8300';
-
-export interface BacktestParams {
-  ticker: string;
-  lookback_days?: number;
-  signals?: number[];
-  fees?: number;
-  slippage?: number;
-  momentum_window?: number;
-  momentum_threshold?: number;
-}
-
-export interface ValidateParams {
-  ticker: string;
-  lookback_days?: number;
-  train_ratio?: number;
-  fees?: number;
-  slippage?: number;
-}
-
-async function post(path: string, body: object): Promise<unknown> {
-  const res = await fetch(`${BASE}${path}`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(body),
-    signal: AbortSignal.timeout(30_000),
-  });
-  if (!res.ok) {
-    const err = await res.json().catch(() => ({ error: res.statusText }));
-    throw new Error((err as { error?: string }).error ?? res.statusText);
-  }
-  return res.json();
-}
-
-export const BacktestAPI = {
-  health: async (): Promise<unknown> => {
-    const res = await fetch(`${BASE}/health`, { signal: AbortSignal.timeout(5_000) });
-    return res.json();
-  },
-
-  backtest: (params: BacktestParams): Promise<unknown> => post('/backtest', params),
-
-  walkForward: (params: ValidateParams): Promise<unknown> => post('/validate', params),
-};

package/src/lib/sml-api/brokers.ts

@@ -1,160 +0,0 @@
-// Broker execution rails — Robinhood + Tradier
-// Robinhood: OAuth2 Bearer token (ROBINHOOD_ACCESS_TOKEN env)
-// Tradier:   Bearer token (TRADIER_API_KEY env, TRADIER_ENV=sandbox|production)
-
-const TRADIER_BASE = process.env.TRADIER_ENV === 'production'
-  ? 'https://api.tradier.com/v1'
-  : 'https://sandbox.tradier.com/v1';
-
-const ROBINHOOD_BASE = 'https://api.robinhood.com';
-
-// ── Shared fetch helpers ────────────────────────────────────────────────────
-
-async function tradierGet(path: string, params?: Record<string, string>): Promise<unknown> {
-  const token = process.env.TRADIER_API_KEY;
-  if (!token) throw new Error('TRADIER_API_KEY not configured');
-  const url = new URL(`${TRADIER_BASE}${path}`);
-  if (params) Object.entries(params).forEach(([k, v]) => url.searchParams.set(k, v));
-  const res = await fetch(url.toString(), {
-    headers: { Authorization: `Bearer ${token}`, Accept: 'application/json' },
-    signal: AbortSignal.timeout(10_000),
-  });
-  if (!res.ok) throw new Error(`Tradier ${res.status}: ${res.statusText}`);
-  return res.json();
-}
-
-async function tradierPost(path: string, body: Record<string, string>): Promise<unknown> {
-  const token = process.env.TRADIER_API_KEY;
-  if (!token) throw new Error('TRADIER_API_KEY not configured');
-  const res = await fetch(`${TRADIER_BASE}${path}`, {
-    method: 'POST',
-    headers: {
-      Authorization: `Bearer ${token}`,
-      Accept: 'application/json',
-      'Content-Type': 'application/x-www-form-urlencoded',
-    },
-    body: new URLSearchParams(body).toString(),
-    signal: AbortSignal.timeout(10_000),
-  });
-  if (!res.ok) throw new Error(`Tradier ${res.status}: ${res.statusText}`);
-  return res.json();
-}
-
-async function robinhoodGet(path: string): Promise<unknown> {
-  const token = process.env.ROBINHOOD_ACCESS_TOKEN;
-  if (!token) throw new Error('ROBINHOOD_ACCESS_TOKEN not configured');
-  const res = await fetch(`${ROBINHOOD_BASE}${path}`, {
-    headers: { Authorization: `Bearer ${token}`, Accept: 'application/json' },
-    signal: AbortSignal.timeout(10_000),
-  });
-  if (!res.ok) throw new Error(`Robinhood ${res.status}: ${res.statusText}`);
-  return res.json();
-}
-
-async function robinhoodPost(path: string, body: object): Promise<unknown> {
-  const token = process.env.ROBINHOOD_ACCESS_TOKEN;
-  if (!token) throw new Error('ROBINHOOD_ACCESS_TOKEN not configured');
-  const res = await fetch(`${ROBINHOOD_BASE}${path}`, {
-    method: 'POST',
-    headers: {
-      Authorization: `Bearer ${token}`,
-      Accept: 'application/json',
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify(body),
-    signal: AbortSignal.timeout(10_000),
-  });
-  if (!res.ok) throw new Error(`Robinhood ${res.status}: ${res.statusText}`);
-  return res.json();
-}
-
-// ── Tradier API ─────────────────────────────────────────────────────────────
-
-export interface TradierQuoteParams { symbols: string }
-export interface TradierOrderParams {
-  account_id: string;
-  symbol: string;
-  side: 'buy' | 'sell';
-  quantity: number;
-  type: 'market' | 'limit' | 'stop' | 'stop_limit';
-  duration: 'day' | 'gtc' | 'pre' | 'post';
-  price?: number;
-  stop?: number;
-}
-
-export const TradierAPI = {
-  quote: (params: TradierQuoteParams) =>
-    tradierGet('/markets/quotes', { symbols: params.symbols, greeks: 'false' }),
-
-  optionChain: (symbol: string, expiration: string) =>
-    tradierGet('/markets/options/chains', { symbol, expiration, greeks: 'true' }),
-
-  order: (params: TradierOrderParams) => {
-    const body: Record<string, string> = {
-      class: 'equity',
-      symbol: params.symbol,
-      side: params.side,
-      quantity: String(params.quantity),
-      type: params.type,
-      duration: params.duration,
-    };
-    if (params.price !== undefined) body.price = String(params.price);
-    if (params.stop !== undefined) body.stop = String(params.stop);
-    return tradierPost(`/accounts/${params.account_id}/orders`, body);
-  },
-
-  positions: (account_id: string) =>
-    tradierGet(`/accounts/${account_id}/positions`),
-
-  balances: (account_id: string) =>
-    tradierGet(`/accounts/${account_id}/balances`),
-
-  orderStatus: (account_id: string, order_id: string) =>
-    tradierGet(`/accounts/${account_id}/orders/${order_id}`),
-};
-
-// ── Robinhood API ────────────────────────────────────────────────────────────
-
-export interface RobinhoodOrderParams {
-  symbol: string;
-  side: 'buy' | 'sell';
-  quantity: number;
-  type: 'market' | 'limit';
-  time_in_force: 'gfd' | 'gtc' | 'ioc' | 'opg';
-  price?: number;
-}
-
-export const RobinhoodAPI = {
-  quote: async (symbol: string) => {
-    const data = await robinhoodGet(`/quotes/?symbols=${symbol}`) as { results?: unknown[] };
-    return data.results?.[0] ?? data;
-  },
-
-  instruments: async (symbol: string) => {
-    const data = await robinhoodGet(`/instruments/?symbol=${symbol}`) as { results?: { url: string }[] };
-    return data.results?.[0];
-  },
-
-  order: async (params: RobinhoodOrderParams) => {
-    const instrument = await RobinhoodAPI.instruments(params.symbol) as { url?: string } | undefined;
-    if (!instrument?.url) throw new Error(`Instrument not found: ${params.symbol}`);
-    const body: Record<string, unknown> = {
-      account: `/accounts/${process.env.ROBINHOOD_ACCOUNT_ID}/`,
-      instrument: instrument.url,
-      symbol: params.symbol,
-      side: params.side,
-      quantity: params.quantity,
-      type: params.type,
-      time_in_force: params.time_in_force,
-      trigger: 'immediate',
-    };
-    if (params.price !== undefined) body.price = String(params.price);
-    return robinhoodPost('/orders/', body);
-  },
-
-  portfolio: () => robinhoodGet('/portfolios/'),
-
-  positions: () => robinhoodGet('/positions/?nonzero=true'),
-
-  orderHistory: () => robinhoodGet('/orders/?page_size=20'),
-};

package/src/lib/sml-api/copytrader.ts

@@ -1,33 +0,0 @@
-const COPYTRADER_BASE = process.env['SML_COPYTRADER_URL'] ?? 'https://sml-copytrader.onrender.com';
-
-async function ctGet(path: string): Promise<unknown> {
-  const res = await fetch(`${COPYTRADER_BASE}${path}`, {
-    headers: { 'Accept': 'application/json' },
-    signal: AbortSignal.timeout(15_000),
-  });
-  if (!res.ok) throw new Error(`CopyTrader GET ${path}: HTTP ${res.status}`);
-  return res.json();
-}
-
-export interface CopyTraderSubscribeParams {
-  whaleAddress: string;
-  subscriberAddress: string;
-  maxCopyAmountXrp: number;
-}
-
-async function ctPost(path: string, body: unknown): Promise<unknown> {
-  const res = await fetch(`${COPYTRADER_BASE}${path}`, {
-    method: 'POST',
-    headers: { 'Accept': 'application/json', 'Content-Type': 'application/json' },
-    body: JSON.stringify(body),
-    signal: AbortSignal.timeout(15_000),
-  });
-  if (!res.ok) throw new Error(`CopyTrader POST ${path}: HTTP ${res.status}`);
-  return res.json();
-}
-
-export const CopyTraderAPI = {
-  status: () => ctGet('/status'),
-  whales: () => ctGet('/whales'),
-  subscribe: (params: CopyTraderSubscribeParams) => ctPost('/subscribe', params),
-};

package/src/lib/sml-api/crawl.ts

@@ -1,44 +0,0 @@
-export interface CrawlParams {
-  url: string;
-  extract: 'text' | 'links' | 'tables' | 'structured' | 'all';
-  userAgent?: string;
-}
-
-export interface CrawlResult {
-  url: string;
-  content: string | unknown;
-  status_code: number;
-  content_type: string;
-  fetched_at: string;
-}
-
-export class CrawlClient {
-  private static instance: CrawlClient;
-  private readonly baseUrl: string;
-
-  private constructor() {
-    this.baseUrl = process.env['SML_API_BASE'] ?? 'https://api.scriptmasterlabs.com';
-  }
-
-  static getInstance(): CrawlClient {
-    if (!CrawlClient.instance) {
-      CrawlClient.instance = new CrawlClient();
-    }
-    return CrawlClient.instance;
-  }
-
-  async fetch(params: CrawlParams): Promise<CrawlResult> {
-    const res = await fetch(`${this.baseUrl}/crawl/v1/fetch`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        ...(params.userAgent ? { 'X-Crawl-User-Agent': params.userAgent } : {}),
-      },
-      body: JSON.stringify({ url: params.url, extract: params.extract }),
-      signal: AbortSignal.timeout(30_000),
-    });
-
-    if (!res.ok) throw new Error(`Crawl API error: HTTP ${res.status}`);
-    return res.json() as Promise<CrawlResult>;
-  }
-}

package/src/lib/sml-api/echo.ts

@@ -1,28 +0,0 @@
-// echo-forge — historical pattern similarity engine (Polygon.io + ML cosine similarity)
-// Status: NOT YET DEPLOYED. Returns informative stub response until service is live.
-
-export interface EchoPatternParams {
-  symbol: string;
-  lookbackDays: number;
-  topN?: number;
-  walletAddress: string;
-}
-
-export const EchoForgeAPI = {
-  patternMatch: async (params: EchoPatternParams): Promise<unknown> => {
-    // Service not yet deployed to Render — surface clear coming-soon message.
-    return {
-      status: 'coming_soon',
-      service: 'echo-forge',
-      message:
-        'echo-forge (historical pattern similarity engine) is not yet deployed. ' +
-        'It uses Polygon.io data + ML cosine similarity to find historical analogs. ' +
-        'Check https://github.com/Timwal78/echo-forge for status updates.',
-      params_received: {
-        symbol: params.symbol,
-        lookback_days: params.lookbackDays,
-        top_n: params.topN ?? 5,
-      },
-    };
-  },
-};

package/src/lib/sml-api/forge.ts

@@ -1,33 +0,0 @@
-const FORGE_BASE = process.env['FORGE_GATEWAY_URL'] ?? 'https://forge-gateway-a822.onrender.com';
-
-async function forgeGet(path: string): Promise<unknown> {
-  const res = await fetch(`${FORGE_BASE}${path}`, {
-    headers: { 'Accept': 'application/json' },
-    signal: AbortSignal.timeout(15_000),
-  });
-  if (!res.ok) throw new Error(`Forge Gateway GET ${path}: HTTP ${res.status}`);
-  return res.json();
-}
-
-export interface ForgeLLMParams {
-  model: string;
-  prompt: string;
-  maxTokens?: number;
-  walletAddress: string;
-}
-
-async function forgePost(path: string, body: unknown): Promise<unknown> {
-  const res = await fetch(`${FORGE_BASE}${path}`, {
-    method: 'POST',
-    headers: { 'Accept': 'application/json', 'Content-Type': 'application/json' },
-    body: JSON.stringify(body),
-    signal: AbortSignal.timeout(60_000),
-  });
-  if (!res.ok) throw new Error(`Forge Gateway POST ${path}: HTTP ${res.status}`);
-  return res.json();
-}
-
-export const ForgeGatewayAPI = {
-  status: () => forgeGet('/health'),
-  llm: (params: ForgeLLMParams) => forgePost('/v1/llm', params),
-};

package/src/lib/sml-api/ftd.ts

@@ -1,53 +0,0 @@
-export interface FtdAlertParams {
-  ticker?: string;
-  minSpikeMultiplier: number;
-}
-
-export interface FtdScanParams {
-  ticker?: string;
-  scanType: 'full' | 'spike_history';
-  minSpikeMultiplier: number;
-}
-
-export class FtdClient {
-  private static instance: FtdClient;
-  private readonly baseUrl: string;
-
-  private constructor() {
-    this.baseUrl = process.env['SML_API_BASE'] ?? 'https://api.scriptmasterlabs.com';
-  }
-
-  static getInstance(): FtdClient {
-    if (!FtdClient.instance) {
-      FtdClient.instance = new FtdClient();
-    }
-    return FtdClient.instance;
-  }
-
-  async getAlerts(params: FtdAlertParams): Promise<unknown> {
-    const qs = new URLSearchParams({ min_spike: String(params.minSpikeMultiplier) });
-    if (params.ticker) qs.set('ticker', params.ticker);
-
-    const res = await fetch(`${this.baseUrl}/ftd/v1/alerts?${qs.toString()}`, {
-      signal: AbortSignal.timeout(10_000),
-    });
-
-    if (!res.ok) throw new Error(`FTD API error: HTTP ${res.status}`);
-    return res.json();
-  }
-
-  async getFullScan(params: FtdScanParams): Promise<unknown> {
-    const qs = new URLSearchParams({
-      scan_type: params.scanType,
-      min_spike: String(params.minSpikeMultiplier),
-    });
-    if (params.ticker) qs.set('ticker', params.ticker);
-
-    const res = await fetch(`${this.baseUrl}/ftd/v1/scan?${qs.toString()}`, {
-      signal: AbortSignal.timeout(10_000),
-    });
-
-    if (!res.ok) throw new Error(`FTD API error: HTTP ${res.status}`);
-    return res.json();
-  }
-}

package/src/lib/sml-api/ghost.ts

@@ -1,35 +0,0 @@
-const GHOST_BASE = process.env['GHOST_LAYER_URL'] ?? 'https://ghost-layer.onrender.com';
-
-async function ghostGet(path: string): Promise<unknown> {
-  const res = await fetch(`${GHOST_BASE}${path}`, {
-    headers: { 'Accept': 'application/json' },
-    signal: AbortSignal.timeout(15_000),
-  });
-  if (!res.ok) throw new Error(`Ghost Layer GET ${path}: HTTP ${res.status}`);
-  return res.json();
-}
-
-export interface GhostRouteParams {
-  fromChain: 'xrpl' | 'base';
-  toChain: 'xrpl' | 'base';
-  amount: string;
-  currency: string;
-  destinationAddress: string;
-  walletAddress: string;
-}
-
-async function ghostPost(path: string, body: unknown): Promise<unknown> {
-  const res = await fetch(`${GHOST_BASE}${path}`, {
-    method: 'POST',
-    headers: { 'Accept': 'application/json', 'Content-Type': 'application/json' },
-    body: JSON.stringify(body),
-    signal: AbortSignal.timeout(15_000),
-  });
-  if (!res.ok) throw new Error(`Ghost Layer POST ${path}: HTTP ${res.status}`);
-  return res.json();
-}
-
-export const GhostLayerAPI = {
-  status: () => ghostGet('/api/status'),
-  route: (params: GhostRouteParams) => ghostPost('/api/route', params),
-};

package/src/lib/sml-api/launchpad.ts

@@ -1,43 +0,0 @@
-const LAUNCHPAD_BASE = process.env['SML_LAUNCHPAD_URL'] ?? 'https://sml-launchpad.onrender.com';
-
-async function lpGet(path: string): Promise<unknown> {
-  const res = await fetch(`${LAUNCHPAD_BASE}${path}`, {
-    headers: { 'Accept': 'application/json' },
-    signal: AbortSignal.timeout(15_000),
-  });
-  if (!res.ok) throw new Error(`Launchpad GET ${path}: HTTP ${res.status}`);
-  return res.json();
-}
-
-export interface LaunchpadCreateParams {
-  name: string;
-  symbol: string;
-  description: string;
-  creatorAddress: string;
-  initialSupply: number;
-  targetLiquidityXrp: number;
-}
-
-export interface LaunchpadBuyParams {
-  tokenAddress: string;
-  buyerAddress: string;
-  xrpAmount: number;
-}
-
-async function lpPost(path: string, body: unknown): Promise<unknown> {
-  const res = await fetch(`${LAUNCHPAD_BASE}${path}`, {
-    method: 'POST',
-    headers: { 'Accept': 'application/json', 'Content-Type': 'application/json' },
-    body: JSON.stringify(body),
-    signal: AbortSignal.timeout(20_000),
-  });
-  if (!res.ok) throw new Error(`Launchpad POST ${path}: HTTP ${res.status}`);
-  return res.json();
-}
-
-export const LaunchpadAPI = {
-  status: () => lpGet('/status'),
-  list: () => lpGet('/tokens'),
-  create: (params: LaunchpadCreateParams) => lpPost('/tokens', params),
-  buy: (params: LaunchpadBuyParams) => lpPost('/tokens/buy', params),
-};

package/src/lib/sml-api/leviathan.ts

@@ -1,49 +0,0 @@
-export interface LeviathanSignalParams {
-  ticker?: string;
-  signalType: 'squeeze' | 'momentum' | 'dark_pool' | 'all';
-  minConfidence: number;
-}
-
-export interface LeviathanSignal {
-  ticker: string;
-  signal_type: string;
-  confidence: number;
-  directive: string;
-  regime: string;
-  timestamp: string;
-  source: string;
-}
-
-export class LeviathanClient {
-  private static instance: LeviathanClient;
-  private readonly baseUrl: string;
-
-  private constructor() {
-    this.baseUrl = process.env['SML_API_BASE'] ?? 'https://api.scriptmasterlabs.com';
-  }
-
-  static getInstance(): LeviathanClient {
-    if (!LeviathanClient.instance) {
-      LeviathanClient.instance = new LeviathanClient();
-    }
-    return LeviathanClient.instance;
-  }
-
-  async getSignal(params: LeviathanSignalParams): Promise<LeviathanSignal[]> {
-    const qs = new URLSearchParams({
-      signal_type: params.signalType,
-      min_confidence: String(params.minConfidence),
-    });
-    if (params.ticker) qs.set('ticker', params.ticker);
-
-    const res = await fetch(`${this.baseUrl}/leviathan/v1/signal?${qs.toString()}`, {
-      signal: AbortSignal.timeout(10_000),
-    });
-
-    if (!res.ok) {
-      throw new Error(`Leviathan API error: HTTP ${res.status}`);
-    }
-
-    return (await res.json()) as LeviathanSignal[];
-  }
-}

package/src/lib/sml-api/nexus.ts

@@ -1,50 +0,0 @@
-export interface NexusQueryParams {
-  capability: string;
-  maxBudget: string;
-}
-
-export interface NexusHireParams {
-  agentId: string;
-  budget: string;
-  chainPreference?: string;
-}
-
-export class NexusClient {
-  private static instance: NexusClient;
-  private readonly baseUrl: string;
-
-  private constructor() {
-    this.baseUrl = process.env['SML_API_BASE'] ?? 'https://api.scriptmasterlabs.com';
-  }
-
-  static getInstance(): NexusClient {
-    if (!NexusClient.instance) {
-      NexusClient.instance = new NexusClient();
-    }
-    return NexusClient.instance;
-  }
-
-  async queryAgents(params: NexusQueryParams): Promise<unknown> {
-    const res = await fetch(`${this.baseUrl}/nexus/v1/agents`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ capability: params.capability, max_budget: params.maxBudget }),
-      signal: AbortSignal.timeout(10_000),
-    });
-
-    if (!res.ok) throw new Error(`Nexus API error: HTTP ${res.status}`);
-    return res.json();
-  }
-
-  async hireAgent(params: NexusHireParams): Promise<unknown> {
-    const res = await fetch(`${this.baseUrl}/nexus/v1/agents/${params.agentId}/hire`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ budget: params.budget, chain_preference: params.chainPreference }),
-      signal: AbortSignal.timeout(10_000),
-    });
-
-    if (!res.ok) throw new Error(`Nexus hire error: HTTP ${res.status}`);
-    return res.json();
-  }
-}

package/src/lib/sml-api/proof402.ts

@@ -1,27 +0,0 @@
-const PROOF402_BASE = process.env['PROOF402_SERVER_URL'] ?? 'https://four02proof.onrender.com';
-
-async function proofGet(path: string): Promise<unknown> {
-  const res = await fetch(`${PROOF402_BASE}${path}`, {
-    headers: { 'Accept': 'application/json' },
-    signal: AbortSignal.timeout(15_000),
-  });
-  if (!res.ok) throw new Error(`402Proof GET ${path}: HTTP ${res.status}`);
-  return res.json();
-}
-
-async function proofPost(path: string, body: unknown): Promise<unknown> {
-  const res = await fetch(`${PROOF402_BASE}${path}`, {
-    method: 'POST',
-    headers: { 'Accept': 'application/json', 'Content-Type': 'application/json' },
-    body: JSON.stringify(body),
-    signal: AbortSignal.timeout(15_000),
-  });
-  if (!res.ok) throw new Error(`402Proof POST ${path}: HTTP ${res.status}`);
-  return res.json();
-}
-
-export const Proof402API = {
-  invoice: (endpointId: string) => proofGet(`/v1/invoice/${encodeURIComponent(endpointId)}`),
-  verify: (txHash: string, endpointId: string) => proofPost('/v1/verify', { tx_hash: txHash, endpoint_id: endpointId }),
-  creditScore: (walletAddress: string) => proofGet(`/v1/credit/${encodeURIComponent(walletAddress)}`),
-};

package/src/lib/sml-api/rails.ts

@@ -1,34 +0,0 @@
-const RAILS_BASE = process.env['SML_RAILS_URL'] ?? 'https://sml-rails.onrender.com';
-
-async function railsGet(path: string): Promise<unknown> {
-  const res = await fetch(`${RAILS_BASE}${path}`, {
-    headers: { 'Accept': 'application/json' },
-    signal: AbortSignal.timeout(15_000),
-  });
-  if (!res.ok) throw new Error(`SML Rails GET ${path}: HTTP ${res.status}`);
-  return res.json();
-}
-
-export interface RailsTransferParams {
-  fromAddress: string;
-  toAddress: string;
-  amount: string;
-  currency: 'RLUSD' | 'XRP';
-  memo?: string;
-}
-
-async function railsPost(path: string, body: unknown): Promise<unknown> {
-  const res = await fetch(`${RAILS_BASE}${path}`, {
-    method: 'POST',
-    headers: { 'Accept': 'application/json', 'Content-Type': 'application/json' },
-    body: JSON.stringify(body),
-    signal: AbortSignal.timeout(20_000),
-  });
-  if (!res.ok) throw new Error(`SML Rails POST ${path}: HTTP ${res.status}`);
-  return res.json();
-}
-
-export const RailsAPI = {
-  status: () => railsGet('/status'),
-  transfer: (params: RailsTransferParams) => railsPost('/transfer', params),
-};