@satelink/sdk 0.2.0

package/src/provider.ts

@@ -0,0 +1,134 @@
+/**
+ * EIP-1193 Compatible Provider
+ * S4-003: Standard Ethereum provider interface for Satelink RPC
+ */
+
+type RequestArguments = {
+  method: string;
+  params?: unknown[] | object;
+};
+
+type EventHandler = (...args: unknown[]) => void;
+
+export interface EIP1193Provider {
+  request(args: RequestArguments): Promise<unknown>;
+  on(event: string, handler: EventHandler): void;
+  removeListener(event: string, handler: EventHandler): void;
+}
+
+export interface SatelinkProviderOptions {
+  chainId?: number;
+  apiKey?: string;
+  baseUrl?: string;
+}
+
+const CHAIN_MAP: Record<number, string> = {
+  1: 'ethereum',
+  137: 'polygon',
+  80002: 'polygon-amoy',
+  42161: 'arbitrum',
+  8453: 'base'
+};
+
+export class SatelinkProvider implements EIP1193Provider {
+  private _chainId: number;
+  private _apiKey: string;
+  private _baseUrl: string;
+  private _listeners: Map<string, Set<EventHandler>> = new Map();
+
+  constructor(options: SatelinkProviderOptions = {}) {
+    this._chainId = options.chainId || 137;
+    this._apiKey = options.apiKey || '';
+    this._baseUrl = options.baseUrl || 'https://rpc.satelink.network';
+  }
+
+  get chainId(): string {
+    return `0x${this._chainId.toString(16)}`;
+  }
+
+  get connected(): boolean {
+    return true;
+  }
+
+  async request({ method, params }: RequestArguments): Promise<unknown> {
+    if (method === 'eth_chainId') {
+      return this.chainId;
+    }
+
+    if (method === 'eth_accounts' || method === 'eth_requestAccounts') {
+      return [];
+    }
+
+    if (method === 'wallet_switchEthereumChain') {
+      const chainIdHex = (params as { chainId: string }[])?.[0]?.chainId;
+      if (chainIdHex) {
+        const newChainId = parseInt(chainIdHex, 16);
+        if (CHAIN_MAP[newChainId]) {
+          const oldChainId = this._chainId;
+          this._chainId = newChainId;
+          if (oldChainId !== newChainId) {
+            this._emit('chainChanged', this.chainId);
+          }
+          return null;
+        }
+        throw { code: 4902, message: 'Chain not supported' };
+      }
+    }
+
+    const chain = CHAIN_MAP[this._chainId] || 'polygon';
+    const url = `${this._baseUrl}/rpc/${chain}`;
+
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json'
+    };
+    if (this._apiKey) {
+      headers['X-API-Key'] = this._apiKey;
+    }
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({
+        jsonrpc: '2.0',
+        id: Date.now(),
+        method,
+        params: params || []
+      })
+    });
+
+    const data = await response.json();
+
+    if (data.error) {
+      throw {
+        code: data.error.code || -32000,
+        message: data.error.message || 'RPC error'
+      };
+    }
+
+    return data.result;
+  }
+
+  on(event: string, handler: EventHandler): void {
+    if (!this._listeners.has(event)) {
+      this._listeners.set(event, new Set());
+    }
+    this._listeners.get(event)!.add(handler);
+  }
+
+  removeListener(event: string, handler: EventHandler): void {
+    this._listeners.get(event)?.delete(handler);
+  }
+
+  private _emit(event: string, ...args: unknown[]): void {
+    this._listeners.get(event)?.forEach(handler => handler(...args));
+  }
+
+  disconnect(): void {
+    this._emit('disconnect', { code: 1000, message: 'User disconnected' });
+    this._listeners.clear();
+  }
+}
+
+export function createSatelinkProvider(options?: SatelinkProviderOptions): SatelinkProvider {
+  return new SatelinkProvider(options);
+}

package/src/rpc.ts

@@ -0,0 +1,132 @@
+import type { SatelinkRPCOptions, JsonRpcRequest, JsonRpcResponse, TransactionRequest } from './types.js';
+
+const DEFAULT_BASE_URL = 'https://rpc.satelink.network';
+const DEFAULT_CHAIN = 'polygon';
+
+export class SatelinkRPC {
+  private apiKey?: string;
+  private chain: string;
+  private baseUrl: string;
+  private requestId = 0;
+
+  constructor(options: SatelinkRPCOptions = {}) {
+    this.apiKey = options.apiKey;
+    this.chain = options.chain || DEFAULT_CHAIN;
+    this.baseUrl = options.baseUrl || DEFAULT_BASE_URL;
+  }
+
+  private getNextId(): number {
+    return ++this.requestId;
+  }
+
+  private getRpcUrl(): string {
+    return `${this.baseUrl}/rpc/${this.chain}`;
+  }
+
+  async request<T = unknown>(method: string, params: unknown[] = []): Promise<T> {
+    const body: JsonRpcRequest = {
+      jsonrpc: '2.0',
+      method,
+      params,
+      id: this.getNextId()
+    };
+
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json'
+    };
+
+    if (this.apiKey) {
+      headers['x-api-key'] = this.apiKey;
+    }
+
+    const response = await fetch(this.getRpcUrl(), {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(body)
+    });
+
+    if (!response.ok) {
+      throw new Error(`RPC request failed: ${response.status} ${response.statusText}`);
+    }
+
+    const data: JsonRpcResponse<T> = await response.json();
+
+    if (data.error) {
+      throw new Error(`RPC error: ${data.error.message} (code: ${data.error.code})`);
+    }
+
+    return data.result as T;
+  }
+
+  async getBlockNumber(): Promise<bigint> {
+    const result = await this.request<string>('eth_blockNumber');
+    return BigInt(result);
+  }
+
+  async getBalance(address: string, block: string = 'latest'): Promise<bigint> {
+    const result = await this.request<string>('eth_getBalance', [address, block]);
+    return BigInt(result);
+  }
+
+  async getTransactionCount(address: string, block: string = 'latest'): Promise<bigint> {
+    const result = await this.request<string>('eth_getTransactionCount', [address, block]);
+    return BigInt(result);
+  }
+
+  async call(tx: TransactionRequest, block: string = 'latest'): Promise<string> {
+    return this.request<string>('eth_call', [tx, block]);
+  }
+
+  async estimateGas(tx: TransactionRequest): Promise<bigint> {
+    const result = await this.request<string>('eth_estimateGas', [tx]);
+    return BigInt(result);
+  }
+
+  async getGasPrice(): Promise<bigint> {
+    const result = await this.request<string>('eth_gasPrice');
+    return BigInt(result);
+  }
+
+  async sendRawTransaction(signedTx: string): Promise<string> {
+    return this.request<string>('eth_sendRawTransaction', [signedTx]);
+  }
+
+  async getTransactionByHash(hash: string): Promise<unknown> {
+    return this.request('eth_getTransactionByHash', [hash]);
+  }
+
+  async getTransactionReceipt(hash: string): Promise<unknown> {
+    return this.request('eth_getTransactionReceipt', [hash]);
+  }
+
+  async getBlockByNumber(block: string | number, fullTx: boolean = false): Promise<unknown> {
+    const blockParam = typeof block === 'number' ? `0x${block.toString(16)}` : block;
+    return this.request('eth_getBlockByNumber', [blockParam, fullTx]);
+  }
+
+  async getChainId(): Promise<bigint> {
+    const result = await this.request<string>('eth_chainId');
+    return BigInt(result);
+  }
+
+  setChain(chain: string): void {
+    this.chain = chain;
+  }
+
+  toProvider(): EIP1193Provider {
+    return {
+      request: async ({ method, params }: { method: string; params?: unknown[] }) => {
+        return this.request(method, params || []);
+      }
+    };
+  }
+}
+
+export interface EIP1193Provider {
+  request: (args: { method: string; params?: unknown[] }) => Promise<unknown>;
+}
+
+export function createProvider(options: SatelinkRPCOptions = {}): EIP1193Provider {
+  const rpc = new SatelinkRPC(options);
+  return rpc.toProvider();
+}

package/src/types.ts

@@ -0,0 +1,73 @@
+export interface SatelinkRPCOptions {
+  apiKey?: string;
+  chain?: string;
+  baseUrl?: string;
+}
+
+export interface SatelinkAIOptions {
+  apiKey: string;
+  baseUrl?: string;
+}
+
+export interface JsonRpcRequest {
+  jsonrpc: '2.0';
+  method: string;
+  params?: unknown[];
+  id: number | string;
+}
+
+export interface JsonRpcResponse<T = unknown> {
+  jsonrpc: '2.0';
+  id: number | string;
+  result?: T;
+  error?: {
+    code: number;
+    message: string;
+    data?: unknown;
+  };
+}
+
+export interface ChatMessage {
+  role: 'system' | 'user' | 'assistant';
+  content: string;
+}
+
+export interface ChatCompletionOptions {
+  model?: string;
+  max_tokens?: number;
+  temperature?: number;
+  stream?: boolean;
+}
+
+export interface ChatCompletionResponse {
+  id: string;
+  object: 'chat.completion';
+  created: number;
+  model: string;
+  choices: Array<{
+    index: number;
+    message: ChatMessage;
+    finish_reason: string;
+  }>;
+  usage: {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+  };
+}
+
+export interface Model {
+  id: string;
+  object: 'model';
+  owned_by: string;
+  created: number;
+}
+
+export interface TransactionRequest {
+  to?: string;
+  from?: string;
+  data?: string;
+  value?: string;
+  gas?: string;
+  gasPrice?: string;
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022", "DOM"],
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}