@make-software/cspr-trade-mcp-sdk 0.1.0

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@make-software/cspr-trade-mcp-sdk",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts && mkdir -p dist/assets && cp src/assets/proxy_caller.wasm dist/assets/",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "casper-js-sdk": "^5.0.6",
+    "big.js": "^6.2.2",
+    "blakejs": "^1.2.1",
+    "@noble/hashes": "^1.7.0"
+  },
+  "devDependencies": {
+    "@types/big.js": "^6.2.2",
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  }
+}

package/src/api/currencies.ts

@@ -0,0 +1,11 @@
+import type { Currency, ApiResponse } from '../types/index.js';
+import type { HttpClient } from './http.js';
+
+export class CurrenciesApi {
+  constructor(private readonly http: HttpClient) {}
+
+  async getCurrencies(): Promise<Currency[]> {
+    const response = await this.http.get<ApiResponse<Currency[]>>('/currencies');
+    return response.data;
+  }
+}

package/src/api/http.ts

@@ -0,0 +1,57 @@
+export class HttpClientError extends Error {
+  constructor(
+    message: string,
+    public readonly status: number,
+    public readonly body?: unknown,
+  ) {
+    super(message);
+    this.name = 'HttpClientError';
+  }
+}
+
+export class HttpClient {
+  constructor(
+    private readonly baseUrl: string,
+    private readonly headers: Record<string, string> = {},
+  ) {}
+
+  async get<T>(path: string, params?: Record<string, string | number | undefined>): Promise<T> {
+    const url = this.buildUrl(path, params);
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: { 'Content-Type': 'application/json', ...this.headers },
+    });
+    return this.handleResponse<T>(response);
+  }
+
+  async post<T>(path: string, body: unknown): Promise<T> {
+    const url = this.buildUrl(path);
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', ...this.headers },
+      body: JSON.stringify(body),
+    });
+    return this.handleResponse<T>(response);
+  }
+
+  private buildUrl(path: string, params?: Record<string, string | number | undefined>): string {
+    const url = new URL(path, this.baseUrl);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+
+  private async handleResponse<T>(response: Response): Promise<T> {
+    const body = await response.json();
+    if (!response.ok) {
+      const message = body?.error?.message ?? body?.message ?? `HTTP ${response.status}`;
+      throw new HttpClientError(message, response.status, body);
+    }
+    return body as T;
+  }
+}

package/src/api/index.ts

@@ -0,0 +1,9 @@
+export { HttpClient, HttpClientError } from './http.js';
+export { TokensApi } from './tokens.js';
+export { PairsApi, type PairQuery, type PaginatedResult } from './pairs.js';
+export { QuotesApi, type QuoteApiParams } from './quotes.js';
+export { LiquidityApi } from './liquidity.js';
+export { RatesApi } from './rates.js';
+export { CurrenciesApi } from './currencies.js';
+export { SwapsApi } from './swaps.js';
+export { SubmissionApi } from './submission.js';

package/src/api/liquidity.ts

@@ -0,0 +1,22 @@
+import type { LiquidityPositionApiResponse, ImpermanentLossApiResponse, ApiResponse } from '../types/index.js';
+import type { HttpClient } from './http.js';
+
+export class LiquidityApi {
+  constructor(private readonly http: HttpClient) {}
+
+  async getPositions(accountIdentifier: string, currencyId?: number): Promise<LiquidityPositionApiResponse[]> {
+    const response = await this.http.get<ApiResponse<LiquidityPositionApiResponse[]>>(
+      `/accounts/${accountIdentifier}/liquidity-positions`,
+      { includes: currencyId !== undefined ? `csprtrade_data(${currencyId})` : undefined }
+    );
+    return response.data;
+  }
+
+  async getImpermanentLoss(accountIdentifier: string, pairHash: string): Promise<ImpermanentLossApiResponse> {
+    const response = await this.http.get<ApiResponse<ImpermanentLossApiResponse>>(
+      `/accounts/${accountIdentifier}/liquidity-position-impermanent-loss`,
+      { pair_contract_package_hash: pairHash }
+    );
+    return response.data;
+  }
+}

package/src/api/pairs.ts

@@ -0,0 +1,77 @@
+import type { Pair, PairApiResponse, PaginatedApiResponse, ApiResponse } from '../types/index.js';
+import type { HttpClient } from './http.js';
+
+export interface PairQuery {
+  page?: number;
+  pageSize?: number;
+  orderBy?: 'timestamp' | 'reserve0' | 'reserve1';
+  orderDirection?: 'asc' | 'desc';
+  token0Hash?: string;
+  token1Hash?: string;
+  currencyId?: number;
+}
+
+export interface PaginatedResult<T> {
+  data: T[];
+  itemCount: number;
+  pageCount: number;
+}
+
+export class PairsApi {
+  constructor(private readonly http: HttpClient) {}
+
+  async getPairs(opts?: PairQuery): Promise<PaginatedResult<Pair>> {
+    const response = await this.http.get<PaginatedApiResponse<PairApiResponse>>('/pairs', {
+      page: opts?.page !== undefined ? String(opts.page) : undefined,
+      page_size: opts?.pageSize !== undefined ? String(opts.pageSize) : undefined,
+      order_by: opts?.orderBy,
+      order_direction: opts?.orderDirection,
+      token0_contract_package_hash: opts?.token0Hash,
+      token1_contract_package_hash: opts?.token1Hash,
+      includes: opts?.currencyId !== undefined ? `csprtrade_data(${opts.currencyId})` : undefined,
+    });
+
+    return {
+      data: response.data.map(mapPair),
+      itemCount: response.item_count,
+      pageCount: response.page_count,
+    };
+  }
+
+  async getPairDetails(contractPackageHash: string, currencyId?: number): Promise<Pair> {
+    const response = await this.http.get<ApiResponse<PairApiResponse>>(
+      `/pairs/${contractPackageHash}`,
+      {
+        includes: currencyId !== undefined ? `csprtrade_data(${currencyId})` : undefined,
+      }
+    );
+    return mapPair(response.data);
+  }
+}
+
+function mapPair(api: PairApiResponse): Pair {
+  const meta0 = api.token0_contract_package?.metadata;
+  const meta1 = api.token1_contract_package?.metadata;
+  return {
+    contractPackageHash: api.contract_package_hash,
+    token0: {
+      packageHash: api.token0_contract_package_hash,
+      symbol: meta0?.symbol ?? '',
+      name: meta0?.name ?? '',
+      decimals: api.decimals0,
+      iconUrl: api.token0_contract_package?.icon_url ?? null,
+    },
+    token1: {
+      packageHash: api.token1_contract_package_hash,
+      symbol: meta1?.symbol ?? '',
+      name: meta1?.name ?? '',
+      decimals: api.decimals1,
+      iconUrl: api.token1_contract_package?.icon_url ?? null,
+    },
+    reserve0: api.reserve0,
+    reserve1: api.reserve1,
+    timestamp: api.timestamp,
+    fiatPrice0: api.token0_contract_package?.csprtrade_data?.price ?? null,
+    fiatPrice1: api.token1_contract_package?.csprtrade_data?.price ?? null,
+  };
+}

package/src/api/quotes.ts

@@ -0,0 +1,23 @@
+import type { QuoteApiResponse, ApiResponse } from '../types/index.js';
+import type { HttpClient } from './http.js';
+
+export interface QuoteApiParams {
+  tokenIn: string;   // contract package hash
+  tokenOut: string;   // contract package hash
+  amount: string;     // raw amount
+  typeId: 1 | 2;     // 1=exact_in, 2=exact_out
+}
+
+export class QuotesApi {
+  constructor(private readonly http: HttpClient) {}
+
+  async getQuote(params: QuoteApiParams): Promise<QuoteApiResponse> {
+    const response = await this.http.get<ApiResponse<QuoteApiResponse>>('/quote', {
+      token_in: params.tokenIn,
+      token_out: params.tokenOut,
+      amount: params.amount,
+      type_id: String(params.typeId),
+    });
+    return response.data;
+  }
+}

package/src/api/rates.ts

@@ -0,0 +1,33 @@
+import type { ApiResponse } from '../types/index.js';
+import type { HttpClient } from './http.js';
+
+export class RatesApi {
+  constructor(private readonly http: HttpClient) {}
+
+  async getCsprRate(currencyId: number): Promise<unknown> {
+    const response = await this.http.get<ApiResponse<unknown>>(`/rates/${currencyId}/latest`);
+    return response.data;
+  }
+
+  async getTokenRate(contractPackageHash: string, currencyId?: number, dexId?: number): Promise<unknown> {
+    const response = await this.http.get<ApiResponse<unknown>>(
+      `/ft/${contractPackageHash}/rates/latest`,
+      {
+        currency_id: currencyId !== undefined ? String(currencyId) : undefined,
+        dex_id: dexId !== undefined ? String(dexId) : undefined,
+      }
+    );
+    return response.data;
+  }
+
+  async getTokenDexRate(contractPackageHash: string, targetHash?: string, dexId?: number): Promise<unknown> {
+    const response = await this.http.get<ApiResponse<unknown>>(
+      `/ft/${contractPackageHash}/dex-rates/latest`,
+      {
+        target_contract_package_hash: targetHash,
+        dex_id: dexId !== undefined ? String(dexId) : undefined,
+      }
+    );
+    return response.data;
+  }
+}

package/src/api/submission.ts

@@ -0,0 +1,42 @@
+import type { HttpClient } from './http.js';
+import type { ApiResponse, SubmitResult } from '../types/index.js';
+
+export interface WasmProxyTransactionParams {
+  callerPublicKey: string;
+  contractPackageHash: string;
+  entryPoint: string;
+  /** Hex-encoded serialized inner args bytes (from Args.toBytes()) */
+  args: string;
+  attachedAmount: number;
+  paymentAmount: number;
+}
+
+export class SubmissionApi {
+  constructor(private readonly http: HttpClient) {}
+
+  /** Ask the API to build an unsigned TransactionV1 with the proxy WASM. */
+  async createWasmProxyTransaction(params: WasmProxyTransactionParams): Promise<unknown> {
+    const response = await this.http.post<ApiResponse<unknown>>(
+      '/wasm-proxy-transaction',
+      {
+        caller_public_key: params.callerPublicKey,
+        contract_package_hash: params.contractPackageHash,
+        entry_point: params.entryPoint,
+        args: params.args,
+        attached_amount: params.attachedAmount,
+        payment_amount: params.paymentAmount,
+      },
+    );
+    return response.data;
+  }
+
+  async submitTransaction(signedTransactionJson: unknown): Promise<SubmitResult> {
+    const response = await this.http.post<ApiResponse<{ api_version: string; transaction_hash: { Version1: string } }>>(
+      '/wasm-proxy-transaction-submission',
+      signedTransactionJson
+    );
+    return {
+      transactionHash: response.data.transaction_hash?.Version1 ?? '',
+    };
+  }
+}

package/src/api/swaps.ts

@@ -0,0 +1,24 @@
+import type { PaginatedApiResponse } from '../types/index.js';
+import type { HttpClient } from './http.js';
+
+export interface SwapApiQuery {
+  senderAccountHash?: string;
+  pairContractPackageHash?: string;
+  page?: number;
+  pageSize?: number;
+  orderDirection?: 'asc' | 'desc';
+}
+
+export class SwapsApi {
+  constructor(private readonly http: HttpClient) {}
+
+  async getSwaps(opts?: SwapApiQuery): Promise<PaginatedApiResponse<unknown>> {
+    return this.http.get<PaginatedApiResponse<unknown>>('/swaps', {
+      sender_hash: opts?.senderAccountHash,
+      pair_contract_package_hash: opts?.pairContractPackageHash,
+      page: opts?.page !== undefined ? String(opts.page) : undefined,
+      page_size: opts?.pageSize !== undefined ? String(opts.pageSize) : undefined,
+      order_direction: opts?.orderDirection,
+    });
+  }
+}

package/src/api/tokens.ts

@@ -0,0 +1,57 @@
+import type { Token, TokenApiResponse, ApiResponse } from '../types/index.js';
+import { CSPR_TOKEN_ID, CSPR_DECIMALS } from '../config.js';
+import type { HttpClient } from './http.js';
+
+export class TokensApi {
+  constructor(
+    private readonly http: HttpClient,
+    private readonly wcsprPackageHash?: string,
+  ) {}
+
+  async getTokens(currencyId?: number): Promise<Token[]> {
+    const response = await this.http.get<ApiResponse<TokenApiResponse[]>>('/tokens', {
+      includes: currencyId !== undefined ? `csprtrade_data(${currencyId})` : undefined,
+    });
+
+    const wcsprHash = this.wcsprPackageHash?.replace('hash-', '') ?? '';
+    const tokens = response.data.map(apiToken => {
+      const rawHash = apiToken.contract_package_hash.replace('hash-', '');
+      // Transform WCSPR into virtual "CSPR" token (matching frontend behavior)
+      if (rawHash === wcsprHash) {
+        const meta = apiToken.contract_package?.metadata;
+        return {
+          id: CSPR_TOKEN_ID,
+          name: 'Casper',
+          symbol: 'CSPR',
+          decimals: meta?.decimals ?? CSPR_DECIMALS,
+          packageHash: apiToken.contract_package_hash,
+          iconUrl: apiToken.contract_package?.icon_url ?? null,
+          fiatPrice: apiToken.contract_package?.csprtrade_data?.price ?? null,
+        };
+      }
+      return mapApiTokenToToken(apiToken);
+    });
+
+    return tokens;
+  }
+
+  async getTokensRaw(currencyId?: number): Promise<TokenApiResponse[]> {
+    const response = await this.http.get<ApiResponse<TokenApiResponse[]>>('/tokens', {
+      includes: currencyId !== undefined ? `csprtrade_data(${currencyId})` : undefined,
+    });
+    return response.data;
+  }
+}
+
+function mapApiTokenToToken(apiToken: TokenApiResponse): Token {
+  const meta = apiToken.contract_package?.metadata;
+  return {
+    id: apiToken.contract_package_hash,
+    name: meta?.name ?? apiToken.contract_package?.name ?? '',
+    symbol: meta?.symbol ?? '',
+    decimals: meta?.decimals ?? 0,
+    packageHash: apiToken.contract_package_hash,
+    iconUrl: apiToken.contract_package?.icon_url ?? null,
+    fiatPrice: apiToken.contract_package?.csprtrade_data?.price ?? null,
+  };
+}

package/src/assets/index.ts

@@ -0,0 +1,21 @@
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+let cachedWasm: Uint8Array | null = null;
+
+export async function getProxyCallerWasm(): Promise<Uint8Array> {
+  if (cachedWasm) return cachedWasm;
+
+  const currentDir = dirname(fileURLToPath(import.meta.url));
+  let buffer: Buffer;
+  try {
+    // Bundled: dist/index.js → dist/assets/proxy_caller.wasm
+    buffer = await readFile(join(currentDir, 'assets', 'proxy_caller.wasm'));
+  } catch {
+    // Source: src/assets/index.ts → src/assets/proxy_caller.wasm
+    buffer = await readFile(join(currentDir, 'proxy_caller.wasm'));
+  }
+  cachedWasm = new Uint8Array(buffer);
+  return cachedWasm;
+}