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

package/dist/index.js

@@ -0,0 +1,1003 @@
+// src/client.ts
+import casperSdk6 from "casper-js-sdk";
+
+// src/api/http.ts
+var HttpClientError = class extends Error {
+  constructor(message, status, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "HttpClientError";
+  }
+};
+var HttpClient = class {
+  constructor(baseUrl, headers = {}) {
+    this.baseUrl = baseUrl;
+    this.headers = headers;
+  }
+  async get(path, params) {
+    const url = this.buildUrl(path, params);
+    const response = await fetch(url, {
+      method: "GET",
+      headers: { "Content-Type": "application/json", ...this.headers }
+    });
+    return this.handleResponse(response);
+  }
+  async post(path, body) {
+    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(response);
+  }
+  buildUrl(path, params) {
+    const url = new URL(path, this.baseUrl);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+  async handleResponse(response) {
+    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;
+  }
+};
+
+// src/config.ts
+var TESTNET_CONFIG = {
+  chainName: "casper-test",
+  apiUrl: "https://cspr-trade-api.dev.make.services",
+  nodeRpcUrl: "https://node.testnet.casper.network/rpc",
+  routerPackageHash: "hash-04a11a367e708c52557930c4e9c1301f4465100d1b1b6d0a62b48d3e32402867",
+  wcsprPackageHash: "hash-3d80df21ba4ee4d66a2a1f60c32570dd5685e4b279f6538162a5fd1314847c1e",
+  gasPrice: 1,
+  ttl: 18e5
+  // 30 minutes
+};
+var MAINNET_CONFIG = {
+  chainName: "casper",
+  apiUrl: "https://api.cspr.trade",
+  nodeRpcUrl: "https://node.mainnet.casper.network/rpc",
+  // TODO: confirm mainnet addresses
+  routerPackageHash: "hash-0000000000000000000000000000000000000000000000000000000000000000",
+  wcsprPackageHash: "hash-0000000000000000000000000000000000000000000000000000000000000000",
+  gasPrice: 1,
+  ttl: 18e5
+};
+function getNetworkConfig(network) {
+  return network === "testnet" ? TESTNET_CONFIG : MAINNET_CONFIG;
+}
+var DEFAULT_SLIPPAGE_BPS = 300;
+var DEFAULT_DEADLINE_MINUTES = 20;
+var GAS_COSTS = {
+  approve: 5000000000n,
+  // 5 CSPR
+  swapCsprForToken: 30000000000n,
+  // 30 CSPR
+  swapTokenForToken: 30000000000n,
+  // 30 CSPR
+  addLiquidity: 50000000000n,
+  // 50 CSPR
+  addNewLiquidity: 500000000000n,
+  // 500 CSPR
+  removeLiquidity: 30000000000n
+  // 30 CSPR
+};
+var CSPR_TOKEN_ID = "cspr";
+var CSPR_DECIMALS = 9;
+var ZERO_HASH = "0000000000000000000000000000000000000000000000000000000000000000";
+var PRICE_IMPACT_WARNING_THRESHOLD = 5;
+var PRICE_IMPACT_HIGH_THRESHOLD = 15;
+var SLIPPAGE_WARNING_THRESHOLD = 10;
+
+// src/api/tokens.ts
+var TokensApi = class {
+  constructor(http, wcsprPackageHash) {
+    this.http = http;
+    this.wcsprPackageHash = wcsprPackageHash;
+  }
+  async getTokens(currencyId) {
+    const response = await this.http.get("/tokens", {
+      includes: currencyId !== void 0 ? `csprtrade_data(${currencyId})` : void 0
+    });
+    const wcsprHash = this.wcsprPackageHash?.replace("hash-", "") ?? "";
+    const tokens = response.data.map((apiToken) => {
+      const rawHash = apiToken.contract_package_hash.replace("hash-", "");
+      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) {
+    const response = await this.http.get("/tokens", {
+      includes: currencyId !== void 0 ? `csprtrade_data(${currencyId})` : void 0
+    });
+    return response.data;
+  }
+};
+function mapApiTokenToToken(apiToken) {
+  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
+  };
+}
+
+// src/api/pairs.ts
+var PairsApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async getPairs(opts) {
+    const response = await this.http.get("/pairs", {
+      page: opts?.page !== void 0 ? String(opts.page) : void 0,
+      page_size: opts?.pageSize !== void 0 ? String(opts.pageSize) : void 0,
+      order_by: opts?.orderBy,
+      order_direction: opts?.orderDirection,
+      token0_contract_package_hash: opts?.token0Hash,
+      token1_contract_package_hash: opts?.token1Hash,
+      includes: opts?.currencyId !== void 0 ? `csprtrade_data(${opts.currencyId})` : void 0
+    });
+    return {
+      data: response.data.map(mapPair),
+      itemCount: response.item_count,
+      pageCount: response.page_count
+    };
+  }
+  async getPairDetails(contractPackageHash, currencyId) {
+    const response = await this.http.get(
+      `/pairs/${contractPackageHash}`,
+      {
+        includes: currencyId !== void 0 ? `csprtrade_data(${currencyId})` : void 0
+      }
+    );
+    return mapPair(response.data);
+  }
+};
+function mapPair(api) {
+  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
+  };
+}
+
+// src/api/quotes.ts
+var QuotesApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async getQuote(params) {
+    const response = await this.http.get("/quote", {
+      token_in: params.tokenIn,
+      token_out: params.tokenOut,
+      amount: params.amount,
+      type_id: String(params.typeId)
+    });
+    return response.data;
+  }
+};
+
+// src/api/liquidity.ts
+var LiquidityApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async getPositions(accountIdentifier, currencyId) {
+    const response = await this.http.get(
+      `/accounts/${accountIdentifier}/liquidity-positions`,
+      { includes: currencyId !== void 0 ? `csprtrade_data(${currencyId})` : void 0 }
+    );
+    return response.data;
+  }
+  async getImpermanentLoss(accountIdentifier, pairHash) {
+    const response = await this.http.get(
+      `/accounts/${accountIdentifier}/liquidity-position-impermanent-loss`,
+      { pair_contract_package_hash: pairHash }
+    );
+    return response.data;
+  }
+};
+
+// src/api/rates.ts
+var RatesApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async getCsprRate(currencyId) {
+    const response = await this.http.get(`/rates/${currencyId}/latest`);
+    return response.data;
+  }
+  async getTokenRate(contractPackageHash, currencyId, dexId) {
+    const response = await this.http.get(
+      `/ft/${contractPackageHash}/rates/latest`,
+      {
+        currency_id: currencyId !== void 0 ? String(currencyId) : void 0,
+        dex_id: dexId !== void 0 ? String(dexId) : void 0
+      }
+    );
+    return response.data;
+  }
+  async getTokenDexRate(contractPackageHash, targetHash, dexId) {
+    const response = await this.http.get(
+      `/ft/${contractPackageHash}/dex-rates/latest`,
+      {
+        target_contract_package_hash: targetHash,
+        dex_id: dexId !== void 0 ? String(dexId) : void 0
+      }
+    );
+    return response.data;
+  }
+};
+
+// src/api/currencies.ts
+var CurrenciesApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async getCurrencies() {
+    const response = await this.http.get("/currencies");
+    return response.data;
+  }
+};
+
+// src/api/swaps.ts
+var SwapsApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async getSwaps(opts) {
+    return this.http.get("/swaps", {
+      sender_hash: opts?.senderAccountHash,
+      pair_contract_package_hash: opts?.pairContractPackageHash,
+      page: opts?.page !== void 0 ? String(opts.page) : void 0,
+      page_size: opts?.pageSize !== void 0 ? String(opts.pageSize) : void 0,
+      order_direction: opts?.orderDirection
+    });
+  }
+};
+
+// src/resolver/token-resolver.ts
+var TokenResolver = class {
+  // 30 seconds
+  constructor(fetchTokens) {
+    this.fetchTokens = fetchTokens;
+  }
+  cache = null;
+  cacheTimestamp = 0;
+  cacheTtlMs = 3e4;
+  async resolve(identifier) {
+    const tokens = await this.getTokens();
+    const id = identifier.trim();
+    const bySymbol = tokens.find((t) => t.symbol.toLowerCase() === id.toLowerCase());
+    if (bySymbol) return bySymbol;
+    const byHash = tokens.find((t) => t.packageHash.toLowerCase() === id.toLowerCase());
+    if (byHash) return byHash;
+    const byName = tokens.find((t) => t.name.toLowerCase() === id.toLowerCase());
+    if (byName) return byName;
+    throw new Error(`Token not found: "${identifier}". Use a token symbol (e.g., "CSPR"), name, or contract package hash.`);
+  }
+  async getTokens() {
+    const now = Date.now();
+    if (this.cache && now - this.cacheTimestamp < this.cacheTtlMs) {
+      return this.cache;
+    }
+    this.cache = await this.fetchTokens();
+    this.cacheTimestamp = now;
+    return this.cache;
+  }
+  invalidateCache() {
+    this.cache = null;
+    this.cacheTimestamp = 0;
+  }
+};
+
+// src/resolver/currency-resolver.ts
+var CurrencyResolver = class {
+  constructor(fetchCurrencies) {
+    this.fetchCurrencies = fetchCurrencies;
+  }
+  cache = null;
+  async resolveToId(code) {
+    const currencies = await this.getCurrencies();
+    const match = currencies.find((c) => c.code.toLowerCase() === code.toLowerCase());
+    return match?.id;
+  }
+  async getCurrencies() {
+    if (this.cache) return this.cache;
+    this.cache = await this.fetchCurrencies();
+    return this.cache;
+  }
+};
+
+// src/utils/amounts.ts
+import Big from "big.js";
+function toRawAmount(humanAmount, decimals) {
+  const big = new Big(humanAmount);
+  const multiplier = new Big(10).pow(decimals);
+  return big.times(multiplier).toFixed(0);
+}
+function toFormattedAmount(rawAmount, decimals) {
+  const big = new Big(rawAmount);
+  const divisor = new Big(10).pow(decimals);
+  const result = big.div(divisor);
+  const str = result.toFixed();
+  if (str.includes(".")) {
+    return str.replace(/\.?0+$/, "") || "0";
+  }
+  return str;
+}
+function calculateMinWithSlippage(rawAmount, slippageBps) {
+  const amount = new Big(rawAmount);
+  const factor = new Big(1).minus(new Big(slippageBps).div(1e4));
+  return amount.times(factor).toFixed(0, Big.roundDown);
+}
+function calculateMaxWithSlippage(rawAmount, slippageBps) {
+  const amount = new Big(rawAmount);
+  const factor = new Big(1).plus(new Big(slippageBps).div(1e4));
+  return amount.times(factor).toFixed(0, Big.roundUp);
+}
+
+// src/transactions/proxy-wasm.ts
+import { hexToBytes } from "@noble/hashes/utils";
+import casperSdk from "casper-js-sdk";
+var { Args, CLTypeUInt8, CLValue } = casperSdk;
+function serializeInnerArgs(args) {
+  return args.toBytes();
+}
+function buildProxyWasmArgs(params) {
+  const { routerPackageHash, entryPoint, innerArgs, attachedValue } = params;
+  const rawArgsBytes = serializeInnerArgs(innerArgs);
+  const argsBytes = [];
+  for (let i = 0; i < rawArgsBytes.length; i++) {
+    argsBytes.push(CLValue.newCLUint8(rawArgsBytes[i]));
+  }
+  return Args.fromMap({
+    package_hash: CLValue.newCLByteArray(hexToBytes(routerPackageHash)),
+    entry_point: CLValue.newCLString(entryPoint),
+    args: CLValue.newCLList(CLTypeUInt8, argsBytes),
+    attached_value: CLValue.newCLUInt512(attachedValue),
+    amount: CLValue.newCLUInt512(attachedValue)
+  });
+}
+
+// src/transactions/swap.ts
+import casperSdk2 from "casper-js-sdk";
+var { Args: Args2, CLTypeKey, CLValue: CLValue2, Key } = casperSdk2;
+function getSwapEntryPoint(isFirstTokenNative, isSecondTokenNative, quoteType) {
+  if (isFirstTokenNative) {
+    return quoteType === "exact_in" ? "swap_exact_cspr_for_tokens" : "swap_cspr_for_exact_tokens";
+  }
+  if (isSecondTokenNative) {
+    return quoteType === "exact_in" ? "swap_exact_tokens_for_cspr" : "swap_tokens_for_exact_cspr";
+  }
+  return quoteType === "exact_in" ? "swap_exact_tokens_for_tokens" : "swap_tokens_for_exact_tokens";
+}
+function buildSwapInnerArgs(params) {
+  const {
+    isFirstTokenNative,
+    isSecondTokenNative,
+    quoteType,
+    path,
+    accountHash,
+    deadline,
+    amountIn,
+    amountOut,
+    amountInMax,
+    amountOutMin
+  } = params;
+  const isBothNotNative = !isFirstTokenNative && !isSecondTokenNative;
+  const argsMap = {
+    path: CLValue2.newCLList(
+      CLTypeKey,
+      path.map((hash) => CLValue2.newCLKey(Key.newKey(hash)))
+    ),
+    to: CLValue2.newCLKey(Key.newKey(accountHash)),
+    deadline: CLValue2.newCLUint64(deadline)
+  };
+  if (isFirstTokenNative && quoteType === "exact_in") {
+    argsMap.amount_out_min = CLValue2.newCLUInt256(amountOutMin);
+  }
+  if (isFirstTokenNative && quoteType === "exact_out") {
+    argsMap.amount_out = CLValue2.newCLUInt256(amountOut);
+  }
+  if ((isSecondTokenNative || isBothNotNative) && quoteType === "exact_in") {
+    argsMap.amount_in = CLValue2.newCLUInt256(amountIn);
+    argsMap.amount_out_min = CLValue2.newCLUInt256(amountOutMin);
+  }
+  if ((isSecondTokenNative || isBothNotNative) && quoteType === "exact_out") {
+    argsMap.amount_in_max = CLValue2.newCLUInt256(amountInMax);
+    argsMap.amount_out = CLValue2.newCLUInt256(amountOut);
+  }
+  return Args2.fromMap(argsMap);
+}
+function getSwapAttachedValue(params) {
+  if (!params.isFirstTokenNative) return "0";
+  return params.quoteType === "exact_in" ? params.amountIn : params.amountInMax;
+}
+
+// src/transactions/liquidity.ts
+import casperSdk3 from "casper-js-sdk";
+var { Args: Args3, CLValue: CLValue3, Key: Key2 } = casperSdk3;
+function buildAddLiquidityInnerArgs(params) {
+  if (params.isCSPRPair) {
+    return Args3.fromMap({
+      token: CLValue3.newCLKey(Key2.newKey(params.tokenHash)),
+      amount_token_desired: CLValue3.newCLUInt256(params.amountTokenDesired),
+      amount_token_min: CLValue3.newCLUInt256(params.amountTokenMin),
+      amount_cspr_min: CLValue3.newCLUInt256(params.amountCSPRMin),
+      to: CLValue3.newCLKey(Key2.newKey(params.accountHash)),
+      deadline: CLValue3.newCLUint64(params.deadline)
+    });
+  }
+  return Args3.fromMap({
+    token_a: CLValue3.newCLKey(Key2.newKey(params.tokenAHash)),
+    token_b: CLValue3.newCLKey(Key2.newKey(params.tokenBHash)),
+    amount_a_desired: CLValue3.newCLUInt256(params.amountADesired),
+    amount_b_desired: CLValue3.newCLUInt256(params.amountBDesired),
+    amount_a_min: CLValue3.newCLUInt256(params.amountAMin),
+    amount_b_min: CLValue3.newCLUInt256(params.amountBMin),
+    to: CLValue3.newCLKey(Key2.newKey(params.accountHash)),
+    deadline: CLValue3.newCLUint64(params.deadline)
+  });
+}
+function buildRemoveLiquidityInnerArgs(params) {
+  if (params.isCSPRPair) {
+    return Args3.fromMap({
+      token: CLValue3.newCLKey(Key2.newKey(params.tokenHash)),
+      liquidity: CLValue3.newCLUInt256(params.liquidity),
+      amount_token_min: CLValue3.newCLUInt256(params.amountTokenMin),
+      amount_cspr_min: CLValue3.newCLUInt256(params.amountCSPRMin),
+      to: CLValue3.newCLKey(Key2.newKey(params.accountHash)),
+      deadline: CLValue3.newCLUint64(params.deadline)
+    });
+  }
+  return Args3.fromMap({
+    token_a: CLValue3.newCLKey(Key2.newKey(params.tokenAHash)),
+    token_b: CLValue3.newCLKey(Key2.newKey(params.tokenBHash)),
+    liquidity: CLValue3.newCLUInt256(params.liquidity),
+    amount_a_min: CLValue3.newCLUInt256(params.amountAMin),
+    amount_b_min: CLValue3.newCLUInt256(params.amountBMin),
+    to: CLValue3.newCLKey(Key2.newKey(params.accountHash)),
+    deadline: CLValue3.newCLUint64(params.deadline)
+  });
+}
+
+// src/transactions/approve.ts
+import casperSdk4 from "casper-js-sdk";
+var { Args: Args4, CLValue: CLValue4, Key: Key3 } = casperSdk4;
+function buildApproveArgs(params) {
+  return Args4.fromMap({
+    spender: CLValue4.newCLKey(Key3.newKey(params.spenderPackageHash)),
+    amount: CLValue4.newCLUInt256(params.amount)
+  });
+}
+
+// src/transactions/transaction-builder.ts
+import casperSdk5 from "casper-js-sdk";
+var { SessionBuilder, ContractCallBuilder, PublicKey } = casperSdk5;
+function buildWasmTransaction(params) {
+  const { publicKey, paymentAmount, wasmBinary, runtimeArgs, networkConfig } = params;
+  return new SessionBuilder().from(PublicKey.fromHex(publicKey)).wasm(wasmBinary).installOrUpgrade().runtimeArgs(runtimeArgs).chainName(networkConfig.chainName).payment(Number(paymentAmount)).ttl(networkConfig.ttl).build();
+}
+function buildContractCallTransaction(params) {
+  const { publicKey, paymentAmount, contractPackageHash, entryPoint, runtimeArgs, networkConfig } = params;
+  const hash = contractPackageHash.replace("hash-", "");
+  return new ContractCallBuilder().from(PublicKey.fromHex(publicKey)).byPackageHash(hash).entryPoint(entryPoint).runtimeArgs(runtimeArgs).chainName(networkConfig.chainName).payment(Number(paymentAmount)).ttl(networkConfig.ttl).build();
+}
+
+// src/assets/index.ts
+import { readFile } from "fs/promises";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+var cachedWasm = null;
+async function getProxyCallerWasm() {
+  if (cachedWasm) return cachedWasm;
+  const currentDir = dirname(fileURLToPath(import.meta.url));
+  let buffer;
+  try {
+    buffer = await readFile(join(currentDir, "assets", "proxy_caller.wasm"));
+  } catch {
+    buffer = await readFile(join(currentDir, "proxy_caller.wasm"));
+  }
+  cachedWasm = new Uint8Array(buffer);
+  return cachedWasm;
+}
+
+// src/client.ts
+var { PublicKey: PublicKey2, HttpHandler, RpcClient, Transaction } = casperSdk6;
+var CsprTradeClient = class {
+  http;
+  tokensApi;
+  pairsApi;
+  quotesApi;
+  liquidityApi;
+  ratesApi;
+  currenciesApi;
+  swapsApi;
+  tokenResolver;
+  currencyResolver;
+  networkConfig;
+  signer;
+  constructor(config) {
+    const baseConfig = getNetworkConfig(config.network);
+    this.networkConfig = {
+      ...baseConfig,
+      apiUrl: config.apiUrl ?? baseConfig.apiUrl,
+      routerPackageHash: config.routerPackageHash ?? baseConfig.routerPackageHash,
+      wcsprPackageHash: config.wcsprPackageHash ?? baseConfig.wcsprPackageHash
+    };
+    this.signer = config.signer;
+    this.http = new HttpClient(this.networkConfig.apiUrl);
+    this.tokensApi = new TokensApi(this.http, this.networkConfig.wcsprPackageHash);
+    this.pairsApi = new PairsApi(this.http);
+    this.quotesApi = new QuotesApi(this.http);
+    this.liquidityApi = new LiquidityApi(this.http);
+    this.ratesApi = new RatesApi(this.http);
+    this.currenciesApi = new CurrenciesApi(this.http);
+    this.swapsApi = new SwapsApi(this.http);
+    this.tokenResolver = new TokenResolver(() => this.tokensApi.getTokens());
+    this.currencyResolver = new CurrencyResolver(() => this.currenciesApi.getCurrencies());
+  }
+  // --- Market Data ---
+  async getTokens(currency) {
+    const currencyId = currency ? await this.currencyResolver.resolveToId(currency) : void 0;
+    return this.tokensApi.getTokens(currencyId);
+  }
+  async getPairs(opts) {
+    const currencyId = opts?.currency ? await this.currencyResolver.resolveToId(opts.currency) : void 0;
+    return this.pairsApi.getPairs({ ...opts, currencyId });
+  }
+  async getPairDetails(pairIdentifier, currency) {
+    const currencyId = currency ? await this.currencyResolver.resolveToId(currency) : void 0;
+    return this.pairsApi.getPairDetails(pairIdentifier, currencyId);
+  }
+  async getQuote(params) {
+    const tokenIn = await this.tokenResolver.resolve(params.tokenIn);
+    const tokenOut = await this.tokenResolver.resolve(params.tokenOut);
+    const rawAmount = toRawAmount(params.amount, params.type === "exact_in" ? tokenIn.decimals : tokenOut.decimals);
+    const quoteTokenIn = tokenIn.id === CSPR_TOKEN_ID ? ZERO_HASH : tokenIn.packageHash;
+    const quoteTokenOut = tokenOut.id === CSPR_TOKEN_ID ? ZERO_HASH : tokenOut.packageHash;
+    const apiQuote = await this.quotesApi.getQuote({
+      tokenIn: quoteTokenIn,
+      tokenOut: quoteTokenOut,
+      amount: rawAmount,
+      typeId: params.type === "exact_in" ? 1 : 2
+    });
+    const tokens = await this.tokenResolver.getTokens();
+    const pathSymbols = apiQuote.path.map((hash) => {
+      const wcsprHash = this.networkConfig.wcsprPackageHash.replace("hash-", "");
+      if (hash.replace("hash-", "") === wcsprHash) return "CSPR";
+      const t = tokens.find((tk) => tk.packageHash.replace("hash-", "") === hash.replace("hash-", ""));
+      return t?.symbol ?? hash.slice(0, 12) + "...";
+    });
+    return {
+      amountIn: apiQuote.amount_in,
+      amountOut: apiQuote.amount_out,
+      amountInFormatted: toFormattedAmount(apiQuote.amount_in, tokenIn.decimals),
+      amountOutFormatted: toFormattedAmount(apiQuote.amount_out, tokenOut.decimals),
+      executionPrice: apiQuote.execution_price,
+      midPrice: apiQuote.mid_price,
+      path: apiQuote.path,
+      pathSymbols,
+      priceImpact: apiQuote.price_impact,
+      recommendedSlippageBps: apiQuote.recommended_slippage_bps,
+      type: params.type,
+      tokenInSymbol: tokenIn.symbol,
+      tokenOutSymbol: tokenOut.symbol,
+      tokenInDecimals: tokenIn.decimals,
+      tokenOutDecimals: tokenOut.decimals
+    };
+  }
+  async getCurrencies() {
+    return this.currenciesApi.getCurrencies();
+  }
+  // --- Account Data ---
+  async getLiquidityPositions(publicKey, currency) {
+    const currencyId = currency ? await this.currencyResolver.resolveToId(currency) : void 0;
+    const raw = await this.liquidityApi.getPositions(publicKey, currencyId);
+    return raw.map(mapLiquidityPosition);
+  }
+  async getImpermanentLoss(publicKey, pairHash) {
+    const raw = await this.liquidityApi.getImpermanentLoss(publicKey, pairHash);
+    return {
+      pairContractPackageHash: raw.pair_contract_package_hash,
+      value: raw.value,
+      timestamp: raw.timestamp
+    };
+  }
+  async getSwapHistory(opts) {
+    const accountHash = opts?.publicKey ? PublicKey2.fromHex(opts.publicKey).accountHash().toHex() : void 0;
+    return this.swapsApi.getSwaps({
+      senderAccountHash: accountHash,
+      pairContractPackageHash: opts?.pairContractPackageHash,
+      page: opts?.page,
+      pageSize: opts?.pageSize
+    });
+  }
+  // --- Transaction Building ---
+  async buildSwap(params) {
+    const tokenIn = await this.tokenResolver.resolve(params.tokenIn);
+    const tokenOut = await this.tokenResolver.resolve(params.tokenOut);
+    const quote = await this.getQuote({
+      tokenIn: params.tokenIn,
+      tokenOut: params.tokenOut,
+      amount: params.amount,
+      type: params.type
+    });
+    const slippageBps = params.slippageBps ?? DEFAULT_SLIPPAGE_BPS;
+    const deadlineMinutes = params.deadlineMinutes ?? DEFAULT_DEADLINE_MINUTES;
+    const deadline = Date.now() + deadlineMinutes * 60 * 1e3;
+    const isFirstTokenNative = tokenIn.id === CSPR_TOKEN_ID;
+    const isSecondTokenNative = tokenOut.id === CSPR_TOKEN_ID;
+    const amountOutMin = calculateMinWithSlippage(quote.amountOut, slippageBps);
+    const amountInMax = calculateMaxWithSlippage(quote.amountIn, slippageBps);
+    const accountHash = PublicKey2.fromHex(params.senderPublicKey).accountHash().toPrefixedString();
+    const path = quote.path.map((h) => h.startsWith("hash-") ? h : `hash-${h}`);
+    const entryPoint = getSwapEntryPoint(isFirstTokenNative, isSecondTokenNative, params.type);
+    const innerArgs = buildSwapInnerArgs({
+      isFirstTokenNative,
+      isSecondTokenNative,
+      quoteType: params.type,
+      path,
+      accountHash,
+      deadline,
+      amountIn: quote.amountIn,
+      amountOut: quote.amountOut,
+      amountInMax,
+      amountOutMin
+    });
+    const attachedValue = getSwapAttachedValue({
+      isFirstTokenNative,
+      quoteType: params.type,
+      amountIn: quote.amountIn,
+      amountInMax
+    });
+    const isBothNotNative = !isFirstTokenNative && !isSecondTokenNative;
+    const gasCost = isBothNotNative ? GAS_COSTS.swapTokenForToken : GAS_COSTS.swapCsprForToken;
+    const proxyArgs = buildProxyWasmArgs({
+      routerPackageHash: this.networkConfig.routerPackageHash.replace("hash-", ""),
+      entryPoint,
+      innerArgs,
+      attachedValue
+    });
+    const wasmBinary = await getProxyCallerWasm();
+    const transaction = buildWasmTransaction({
+      publicKey: params.senderPublicKey,
+      paymentAmount: gasCost.toString(),
+      wasmBinary,
+      runtimeArgs: proxyArgs,
+      networkConfig: this.networkConfig
+    });
+    const warnings = buildWarnings(quote.priceImpact, slippageBps);
+    const approvals = [];
+    if (!isFirstTokenNative) {
+      const approvalAmount = params.tokenInBalance ?? quote.amountIn;
+      const approval = await this.buildApproval({
+        tokenContractPackageHash: tokenIn.packageHash,
+        spenderPackageHash: this.networkConfig.routerPackageHash,
+        amount: approvalAmount,
+        senderPublicKey: params.senderPublicKey
+      });
+      approval.summary = params.tokenInBalance ? `Approve ${tokenIn.symbol} for router (full balance \u2014 one-time)` : `Approve ${tokenIn.symbol} for router (swap amount only)`;
+      approvals.push(approval);
+    }
+    const slippagePct = (slippageBps / 100).toFixed(2);
+    const summary = [
+      `Swap ${quote.amountInFormatted} ${tokenIn.symbol} for ~${quote.amountOutFormatted} ${tokenOut.symbol}`,
+      `Route: ${quote.pathSymbols.join(" \u2192 ")}`,
+      `Price impact: ${quote.priceImpact}%`,
+      `Max slippage: ${slippagePct}%`,
+      `Deadline: ${deadlineMinutes} minutes`,
+      `Estimated gas: ${Number(gasCost) / 1e9} CSPR`
+    ].join("\n");
+    return {
+      transactionJson: JSON.stringify(transaction.toJSON()),
+      summary,
+      estimatedGasCost: `${Number(gasCost) / 1e9} CSPR`,
+      approvalsRequired: approvals.length > 0 ? approvals : void 0,
+      warnings
+    };
+  }
+  async buildApproval(params) {
+    const spender = params.spenderPackageHash || this.networkConfig.routerPackageHash;
+    const args = buildApproveArgs({
+      spenderPackageHash: spender,
+      amount: params.amount
+    });
+    const transaction = buildContractCallTransaction({
+      publicKey: params.senderPublicKey,
+      paymentAmount: GAS_COSTS.approve.toString(),
+      contractPackageHash: params.tokenContractPackageHash,
+      entryPoint: "approve",
+      runtimeArgs: args,
+      networkConfig: this.networkConfig
+    });
+    return {
+      transactionJson: JSON.stringify(transaction.toJSON()),
+      summary: `Approve token spending for ${params.tokenContractPackageHash.slice(0, 16)}...`,
+      estimatedGasCost: `${Number(GAS_COSTS.approve) / 1e9} CSPR`,
+      warnings: []
+    };
+  }
+  async buildAddLiquidity(params) {
+    const tokenA = await this.tokenResolver.resolve(params.tokenA);
+    const tokenB = await this.tokenResolver.resolve(params.tokenB);
+    const slippageBps = params.slippageBps ?? DEFAULT_SLIPPAGE_BPS;
+    const deadlineMinutes = params.deadlineMinutes ?? DEFAULT_DEADLINE_MINUTES;
+    const deadline = Date.now() + deadlineMinutes * 60 * 1e3;
+    const isCSPRPair = tokenA.id === CSPR_TOKEN_ID || tokenB.id === CSPR_TOKEN_ID;
+    const rawAmountA = toRawAmount(params.amountA, tokenA.decimals);
+    const rawAmountB = toRawAmount(params.amountB, tokenB.decimals);
+    const accountHash = PublicKey2.fromHex(params.senderPublicKey).accountHash().toPrefixedString();
+    let innerArgs;
+    let entryPoint;
+    let attachedValue = "0";
+    if (isCSPRPair) {
+      const csprToken = tokenA.id === CSPR_TOKEN_ID ? tokenA : tokenB;
+      const otherToken = tokenA.id === CSPR_TOKEN_ID ? tokenB : tokenA;
+      const motesAmount = tokenA.id === CSPR_TOKEN_ID ? rawAmountA : rawAmountB;
+      const tokenAmount = tokenA.id === CSPR_TOKEN_ID ? rawAmountB : rawAmountA;
+      innerArgs = buildAddLiquidityInnerArgs({
+        isCSPRPair: true,
+        tokenHash: otherToken.packageHash,
+        amountTokenDesired: tokenAmount,
+        amountTokenMin: calculateMinWithSlippage(tokenAmount, slippageBps),
+        amountCSPRMin: calculateMinWithSlippage(motesAmount, slippageBps),
+        accountHash,
+        deadline
+      });
+      entryPoint = "add_liquidity_cspr";
+      attachedValue = motesAmount;
+    } else {
+      const [sortedA, sortedB, sortedAmountA, sortedAmountB] = tokenA.packageHash < tokenB.packageHash ? [tokenA, tokenB, rawAmountA, rawAmountB] : [tokenB, tokenA, rawAmountB, rawAmountA];
+      innerArgs = buildAddLiquidityInnerArgs({
+        isCSPRPair: false,
+        tokenAHash: sortedA.packageHash,
+        tokenBHash: sortedB.packageHash,
+        amountADesired: sortedAmountA,
+        amountBDesired: sortedAmountB,
+        amountAMin: calculateMinWithSlippage(sortedAmountA, slippageBps),
+        amountBMin: calculateMinWithSlippage(sortedAmountB, slippageBps),
+        accountHash,
+        deadline
+      });
+      entryPoint = "add_liquidity";
+    }
+    const gasCost = GAS_COSTS.addLiquidity;
+    const proxyArgs = buildProxyWasmArgs({
+      routerPackageHash: this.networkConfig.routerPackageHash.replace("hash-", ""),
+      entryPoint,
+      innerArgs,
+      attachedValue
+    });
+    const wasmBinary = await getProxyCallerWasm();
+    const transaction = buildWasmTransaction({
+      publicKey: params.senderPublicKey,
+      paymentAmount: gasCost.toString(),
+      wasmBinary,
+      runtimeArgs: proxyArgs,
+      networkConfig: this.networkConfig
+    });
+    const tokenBalances = [params.tokenABalance, params.tokenBBalance];
+    const rawAmounts = [rawAmountA, rawAmountB];
+    const approvals = [];
+    for (let i = 0; i < 2; i++) {
+      const token = [tokenA, tokenB][i];
+      if (token.id === CSPR_TOKEN_ID) continue;
+      const approvalAmount = tokenBalances[i] ?? rawAmounts[i];
+      const approval = await this.buildApproval({
+        tokenContractPackageHash: token.packageHash,
+        spenderPackageHash: this.networkConfig.routerPackageHash,
+        amount: approvalAmount,
+        senderPublicKey: params.senderPublicKey
+      });
+      approval.summary = tokenBalances[i] ? `Approve ${token.symbol} for router (full balance \u2014 one-time)` : `Approve ${token.symbol} for router (liquidity amount only)`;
+      approvals.push(approval);
+    }
+    const summary = [
+      `Add liquidity: ${params.amountA} ${tokenA.symbol} + ${params.amountB} ${tokenB.symbol}`,
+      `Slippage tolerance: ${(slippageBps / 100).toFixed(2)}%`,
+      `Deadline: ${deadlineMinutes} minutes`,
+      `Estimated gas: ${Number(gasCost) / 1e9} CSPR`
+    ].join("\n");
+    return {
+      transactionJson: JSON.stringify(transaction.toJSON()),
+      summary,
+      estimatedGasCost: `${Number(gasCost) / 1e9} CSPR`,
+      approvalsRequired: approvals.length > 0 ? approvals : void 0,
+      warnings: []
+    };
+  }
+  async buildRemoveLiquidity(params) {
+    const positions = await this.liquidityApi.getPositions(params.senderPublicKey);
+    const position = positions.find(
+      (p) => p.pair_contract_package_hash === params.pairContractPackageHash
+    );
+    if (!position) {
+      throw new Error(`No liquidity position found for pair ${params.pairContractPackageHash}`);
+    }
+    const slippageBps = params.slippageBps ?? DEFAULT_SLIPPAGE_BPS;
+    const deadlineMinutes = params.deadlineMinutes ?? DEFAULT_DEADLINE_MINUTES;
+    const deadline = Date.now() + deadlineMinutes * 60 * 1e3;
+    const accountHash = PublicKey2.fromHex(params.senderPublicKey).accountHash().toPrefixedString();
+    const lpBalance = BigInt(position.lp_token_balance);
+    const lpToBurn = lpBalance * BigInt(params.percentage) / 100n;
+    const lpTotalSupply = BigInt(position.pair_lp_tokens_total_supply);
+    const reserve0 = BigInt(position.pair.reserve0);
+    const reserve1 = BigInt(position.pair.reserve1);
+    const estAmount0 = (lpToBurn * reserve0 / lpTotalSupply).toString();
+    const estAmount1 = (lpToBurn * reserve1 / lpTotalSupply).toString();
+    const wcsprHash = this.networkConfig.wcsprPackageHash.replace("hash-", "");
+    const isCSPRPair = position.pair.token0_contract_package_hash.replace("hash-", "") === wcsprHash || position.pair.token1_contract_package_hash.replace("hash-", "") === wcsprHash;
+    let innerArgs;
+    let entryPoint;
+    if (isCSPRPair) {
+      const isToken0CSPR = position.pair.token0_contract_package_hash.replace("hash-", "") === wcsprHash;
+      innerArgs = buildRemoveLiquidityInnerArgs({
+        isCSPRPair: true,
+        tokenHash: isToken0CSPR ? position.pair.token1_contract_package_hash : position.pair.token0_contract_package_hash,
+        liquidity: lpToBurn.toString(),
+        amountTokenMin: calculateMinWithSlippage(isToken0CSPR ? estAmount1 : estAmount0, slippageBps),
+        amountCSPRMin: calculateMinWithSlippage(isToken0CSPR ? estAmount0 : estAmount1, slippageBps),
+        accountHash,
+        deadline
+      });
+      entryPoint = "remove_liquidity_cspr";
+    } else {
+      innerArgs = buildRemoveLiquidityInnerArgs({
+        isCSPRPair: false,
+        tokenAHash: position.pair.token0_contract_package_hash,
+        tokenBHash: position.pair.token1_contract_package_hash,
+        liquidity: lpToBurn.toString(),
+        amountAMin: calculateMinWithSlippage(estAmount0, slippageBps),
+        amountBMin: calculateMinWithSlippage(estAmount1, slippageBps),
+        accountHash,
+        deadline
+      });
+      entryPoint = "remove_liquidity";
+    }
+    const proxyArgs = buildProxyWasmArgs({
+      routerPackageHash: this.networkConfig.routerPackageHash.replace("hash-", ""),
+      entryPoint,
+      innerArgs,
+      attachedValue: "0"
+    });
+    const wasmBinary = await getProxyCallerWasm();
+    const transaction = buildWasmTransaction({
+      publicKey: params.senderPublicKey,
+      paymentAmount: GAS_COSTS.removeLiquidity.toString(),
+      wasmBinary,
+      runtimeArgs: proxyArgs,
+      networkConfig: this.networkConfig
+    });
+    const summary = [
+      `Remove ${params.percentage}% liquidity from pair ${params.pairContractPackageHash.slice(0, 16)}...`,
+      `LP tokens to burn: ${lpToBurn.toString()}`,
+      `Estimated gas: ${Number(GAS_COSTS.removeLiquidity) / 1e9} CSPR`
+    ].join("\n");
+    return {
+      transactionJson: JSON.stringify(transaction.toJSON()),
+      summary,
+      estimatedGasCost: `${Number(GAS_COSTS.removeLiquidity) / 1e9} CSPR`,
+      warnings: []
+    };
+  }
+  // --- Transaction Submission ---
+  /** Submit a signed transaction to the Casper node RPC */
+  async submitTransaction(signedTransactionJson) {
+    const handler = new HttpHandler(this.networkConfig.nodeRpcUrl);
+    const rpcClient = new RpcClient(handler);
+    const transaction = Transaction.fromJSON(JSON.parse(signedTransactionJson));
+    const result = await rpcClient.putTransaction(transaction);
+    return {
+      transactionHash: result.transactionHash?.toHex() ?? ""
+    };
+  }
+  /** @deprecated Use submitTransaction instead — all transactions now submit via node RPC */
+  async submitTransactionDirect(signedTransactionJson) {
+    return this.submitTransaction(signedTransactionJson);
+  }
+  // --- Token Resolution ---
+  async resolveToken(identifier) {
+    return this.tokenResolver.resolve(identifier);
+  }
+};
+function mapLiquidityPosition(raw) {
+  const lpBalance = BigInt(raw.lp_token_balance);
+  const totalSupply = BigInt(raw.pair_lp_tokens_total_supply);
+  const reserve0 = BigInt(raw.pair.reserve0);
+  const reserve1 = BigInt(raw.pair.reserve1);
+  const poolShare = totalSupply > 0n ? (lpBalance * 10000n / totalSupply).toString() : "0";
+  const estToken0 = totalSupply > 0n ? (lpBalance * reserve0 / totalSupply).toString() : "0";
+  const estToken1 = totalSupply > 0n ? (lpBalance * reserve1 / totalSupply).toString() : "0";
+  const meta0 = raw.pair.token0_contract_package?.metadata;
+  const meta1 = raw.pair.token1_contract_package?.metadata;
+  return {
+    accountHash: raw.account_hash,
+    pairContractPackageHash: raw.pair_contract_package_hash,
+    lpTokenBalance: raw.lp_token_balance,
+    lpTokenTotalSupply: raw.pair_lp_tokens_total_supply,
+    pair: {
+      token0Symbol: meta0?.symbol ?? "",
+      token1Symbol: meta1?.symbol ?? "",
+      token0PackageHash: raw.pair.token0_contract_package_hash,
+      token1PackageHash: raw.pair.token1_contract_package_hash,
+      reserve0: raw.pair.reserve0,
+      reserve1: raw.pair.reserve1,
+      decimals0: raw.pair.decimals0,
+      decimals1: raw.pair.decimals1
+    },
+    poolShare: (Number(poolShare) / 100).toFixed(2),
+    estimatedToken0Amount: estToken0,
+    estimatedToken1Amount: estToken1
+  };
+}
+function buildWarnings(priceImpact, slippageBps) {
+  const warnings = [];
+  const impact = parseFloat(priceImpact);
+  if (impact > PRICE_IMPACT_HIGH_THRESHOLD) {
+    warnings.push(`HIGH PRICE IMPACT: ${priceImpact}% \u2014 you will lose a significant portion of your trade to price impact.`);
+  } else if (impact > PRICE_IMPACT_WARNING_THRESHOLD) {
+    warnings.push(`Price impact is ${priceImpact}% \u2014 consider trading a smaller amount.`);
+  }
+  if (slippageBps / 100 > SLIPPAGE_WARNING_THRESHOLD) {
+    warnings.push(`High slippage tolerance: ${(slippageBps / 100).toFixed(2)}% \u2014 you may receive significantly less than quoted.`);
+  }
+  return warnings;
+}
+export {
+  CsprTradeClient,
+  MAINNET_CONFIG,
+  TESTNET_CONFIG,
+  calculateMaxWithSlippage,
+  calculateMinWithSlippage,
+  getNetworkConfig,
+  toFormattedAmount,
+  toRawAmount
+};