@strkfarm/sdk 2.0.0-dev.3 → 2.0.0-dev.30

package/src/modules/ExtendedWrapperSDk/wrapper.ts

@@ -3,6 +3,7 @@
  * Provides a clean interface to interact with the Extended Exchange trading API
  */
 
+import BigNumber from "bignumber.js";
 import {
   CreateOrderRequest,
   WithdrawRequest,
@@ -22,20 +23,99 @@ import {
   AssetOperationType,
   AssetOperationStatus,
   FundingRate,
+  FundingPayment,
   UpdateLeverageRequest,
 } from "./types";
 
+type ExtendedTradingRules = {
+  minOrderSize: BigNumber;
+  qtyStep: BigNumber;
+  priceStep: BigNumber;
+};
+
+function asRecord(v: unknown): Record<string, unknown> | null {
+  return v !== null && typeof v === "object" && !Array.isArray(v)
+    ? (v as Record<string, unknown>)
+    : null;
+}
+
+function pickTradingConfig(row: Record<string, unknown>): Record<string, unknown> | null {
+  const tc = row.trading_config ?? row.tradingConfig;
+  return asRecord(tc);
+}
+
+function readTcString(
+  tc: Record<string, unknown>,
+  snake: string,
+  camel: string,
+): string | undefined {
+  const v = tc[snake] ?? tc[camel];
+  if (v === undefined || v === null) return undefined;
+  return String(v).trim();
+}
+
+function tradingRulesFromMarketRow(
+  marketName: string,
+  row: unknown,
+): ExtendedTradingRules {
+  const r = asRecord(row);
+  if (!r) {
+    throw new Error(`ExtendedWrapper: invalid market payload for ${marketName}`);
+  }
+  const tc = pickTradingConfig(r);
+  if (!tc) {
+    throw new Error(`ExtendedWrapper: missing tradingConfig for market ${marketName}`);
+  }
+  const minS = readTcString(tc, "min_order_size", "minOrderSize");
+  const qtyStep = readTcString(tc, "min_order_size_change", "minOrderSizeChange");
+  const pxStep = readTcString(tc, "min_price_change", "minPriceChange");
+  if (!minS || !qtyStep || !pxStep) {
+    throw new Error(`ExtendedWrapper: incomplete tradingConfig for market ${marketName}`);
+  }
+  const minOrderSize = new BigNumber(minS);
+  const qty = new BigNumber(qtyStep);
+  const px = new BigNumber(pxStep);
+  if (!minOrderSize.isFinite() || minOrderSize.lte(0)) {
+    throw new Error(`ExtendedWrapper: invalid minOrderSize for ${marketName}`);
+  }
+  if (!qty.isFinite() || qty.lte(0)) {
+    throw new Error(`ExtendedWrapper: invalid minOrderSizeChange for ${marketName}`);
+  }
+  if (!px.isFinite() || px.lte(0)) {
+    throw new Error(`ExtendedWrapper: invalid minPriceChange for ${marketName}`);
+  }
+  return { minOrderSize, qtyStep: qty, priceStep: px };
+}
+
+function roundToStepBn(value: BigNumber, step: BigNumber): BigNumber {
+  if (step.lte(0)) return value;
+  return value.div(step).round(0, BigNumber.ROUND_HALF_UP).times(step);
+}
+
+function formatBnForApi(bn: BigNumber, step: BigNumber): string {
+  const dp = Math.max(step.decimalPlaces() ?? 0, bn.decimalPlaces() ?? 0, 0);
+  return Number(bn.toFixed(Math.min(80, dp))).toString();
+}
+
 export class ExtendedWrapper {
-  private baseUrl: string;
+  private readUrl: string;
+  private writeUrl: string;
   private apiKey?: string;
   private timeout: number;
   private retries: number;
+  /** Per-market rules from GET /markets (tradingConfig); retained for process lifetime (no TTL). */
+  private marketTradingRulesCache = new Map<string, ExtendedTradingRules>();
+  private marketTradingRulesInflight = new Map<
+    string,
+    Promise<ExtendedTradingRules>
+  >();
 
   constructor(config: ExtendedWrapperConfig) {
-    this.baseUrl = config.baseUrl.replace(/\/$/, ""); // Remove trailing slash
     this.apiKey = config.apiKey;
     this.timeout = config.timeout || 30000; // 30 seconds default
     this.retries = config.retries || 3;
+    this.readUrl = config.readUrl.replace(/\/$/, "");
+    this.writeUrl = config.writeUrl.replace(/\/$/, "");
   }
 
   /**
@@ -43,15 +123,14 @@ export class ExtendedWrapper {
    */
   private async makeRequest<T>(
     endpoint: string,
-    options: RequestInit = {}
+    isRead: boolean,
+    options: RequestInit = {},
   ): Promise<ExtendedApiResponse<T>> {
-    const url = `${this.baseUrl}${endpoint}`;
-
+    const url = `${isRead ? this.readUrl : this.writeUrl}${endpoint}`;
     const headers: Record<string, any> = {
       "Content-Type": "application/json",
       ...options.headers,
     };
-
     if (this.apiKey) {
       headers["X-API-Key"] = this.apiKey;
     }
@@ -73,11 +152,42 @@ export class ExtendedWrapper {
           throw new Error(
             `HTTP ${response.status}: ${
               errorData.detail || response.statusText
-            }`
+            }`,
           );
         }
 
-        const data = await response.json();
+        const text = await response.text();
+
+        // Replace large integers (greater than MAX_SAFE_INTEGER) with quoted strings
+        // This regex finds numbers that are likely to be large integers in the "data" field
+        const MAX_SAFE_INTEGER_STR = "9007199254740991";
+        const largeIntegerRegex = /"data"\s*:\s*(\d{16,})/g;
+
+        const modifiedText = text.replace(
+          largeIntegerRegex,
+          (match, largeInt) => {
+            // Compare as strings to avoid precision loss
+            if (
+              largeInt.length > MAX_SAFE_INTEGER_STR.length ||
+              (largeInt.length === MAX_SAFE_INTEGER_STR.length &&
+                largeInt > MAX_SAFE_INTEGER_STR)
+            ) {
+              // Replace the number with a quoted string to preserve precision
+              return `"data":"${largeInt}"`;
+            }
+            return match; // Keep original if it's a safe integer
+          },
+        );
+
+        const data = JSON.parse(modifiedText);
+
+        if (data && typeof data.data === "string" && /^\d+$/.test(data.data)) {
+          const numValue = Number(data.data);
+          if (Number.isSafeInteger(numValue)) {
+            data.data = numValue;
+          }
+        }
+
         return data;
       } catch (error) {
         lastError = error as Error;
@@ -93,15 +203,80 @@ export class ExtendedWrapper {
     throw lastError || new Error("Request failed after all retries");
   }
 
+  private async resolveTradingRules(
+    marketName: string,
+  ): Promise<ExtendedTradingRules> {
+    const cached = this.marketTradingRulesCache.get(marketName);
+    if (cached) return cached;
+    const existing = this.marketTradingRulesInflight.get(marketName);
+    if (existing) return existing;
+    const inflight = (async () => {
+      const res = await this.getMarkets(marketName);
+      if (res.status !== "OK") {
+        throw new Error(
+          `ExtendedWrapper: getMarkets failed for ${marketName}: ${res.message}`,
+        );
+      }
+      const rows = res.data;
+      if (!Array.isArray(rows) || rows.length === 0) {
+        throw new Error(
+          `ExtendedWrapper: empty markets response for ${marketName}`,
+        );
+      }
+      const row = rows.find((m) => asRecord(m)?.name === marketName);
+      if (!row) {
+        throw new Error(
+          `ExtendedWrapper: market ${marketName} not found in markets list`,
+        );
+      }
+      const rules = tradingRulesFromMarketRow(marketName, row);
+      this.marketTradingRulesCache.set(marketName, rules);
+      return rules;
+    })();
+    this.marketTradingRulesInflight.set(marketName, inflight);
+    void inflight.finally(() => {
+      if (this.marketTradingRulesInflight.get(marketName) === inflight) {
+        this.marketTradingRulesInflight.delete(marketName);
+      }
+    });
+    return inflight;
+  }
+
   /**
    * Create a new order on Extended Exchange
    */
   async createOrder(
-    request: CreateOrderRequest
+    request: CreateOrderRequest,
   ): Promise<ExtendedApiResponse<PlacedOrder>> {
-    return this.makeRequest<PlacedOrder>("/api/v1/orders", {
+    const rules = await this.resolveTradingRules(request.market_name);
+    const amountBn = new BigNumber(String(request.amount).trim());
+    const priceBn = new BigNumber(String(request.price).trim());
+    if (!amountBn.isFinite() || amountBn.lte(0)) {
+      throw new Error(`ExtendedWrapper: invalid order amount=${request.amount}`);
+    }
+    if (!priceBn.isFinite() || priceBn.lte(0)) {
+      throw new Error(`ExtendedWrapper: invalid order price=${request.price}`);
+    }
+    if (amountBn.lt(rules.minOrderSize)) {
+      throw new Error(
+        `ExtendedWrapper: order amount ${request.amount} is below minOrderSize ${rules.minOrderSize.toFixed()} for ${request.market_name}`,
+      );
+    }
+    const adjAmount = roundToStepBn(amountBn, rules.qtyStep);
+    const adjPrice = roundToStepBn(priceBn, rules.priceStep);
+    if (adjAmount.lt(rules.minOrderSize)) {
+      throw new Error(
+        `ExtendedWrapper: amount after tick rounding ${formatBnForApi(adjAmount, rules.qtyStep)} is below minOrderSize ${rules.minOrderSize.toFixed()} (${request.market_name})`,
+      );
+    }
+    const payload: CreateOrderRequest = {
+      ...request,
+      amount: formatBnForApi(adjAmount, rules.qtyStep),
+      price: formatBnForApi(adjPrice, rules.priceStep),
+    };
+    return this.makeRequest<PlacedOrder>("/api/v1/orders", false, {
       method: "POST",
-      body: JSON.stringify(request),
+      body: JSON.stringify(payload),
     });
   }
 
@@ -109,32 +284,35 @@ export class ExtendedWrapper {
    * Get all markets
    */
   async getMarkets(
-    marketNames?: string
+    marketNames?: string,
   ): Promise<ExtendedApiResponse<Market[]>> {
     const params = marketNames
       ? `?market_names=${encodeURIComponent(marketNames)}`
       : "";
-    return this.makeRequest<Market[]>(`/api/v1/markets${params}`);
+    return this.makeRequest<Market[]>(`/api/v1/markets${params}`, false);
   }
 
-   /**
-   * 
+  /**
+   *
    * @param orderId - The ID of the order to get
    * @returns The order
    */
-   async getOrderByOrderId(orderId: string): Promise<ExtendedApiResponse<OpenOrder>> {
+  async getOrderByOrderId(
+    orderId: string,
+  ): Promise<ExtendedApiResponse<OpenOrder>> {
     const orderIdInt = parseInt(orderId);
-    return this.makeRequest<OpenOrder>(`/api/v1/orderId/${orderIdInt}`);
+    return this.makeRequest<OpenOrder>(`/api/v1/orderId/${orderIdInt}`, false);
   }
 
   /**
    * Get market statistics for a specific market
    */
   async getMarketStatistics(
-    marketName: string
+    marketName: string,
   ): Promise<ExtendedApiResponse<MarketStats>> {
     return this.makeRequest<MarketStats>(
-      `/api/v1/markets/statistics?market_name=${encodeURIComponent(marketName)}`
+      `/api/v1/markets/statistics?market_name=${encodeURIComponent(marketName)}`,
+      false,
     );
   }
 
@@ -142,28 +320,30 @@ export class ExtendedWrapper {
    * Get current trading positions
    */
   async getPositions(
-    marketNames?: string
+    marketNames?: string,
   ): Promise<ExtendedApiResponse<Position[]>> {
     const params = marketNames
       ? `?market_names=${encodeURIComponent(marketNames)}`
       : "";
-    return this.makeRequest<Position[]>(`/api/v1/positions${params}`);
+    const response = await this.makeRequest<Position[]>(`/api/v1/positions${params}`, true);
+    return response;
   }
 
   /**
    * Get account balance and holdings
    */
   async getHoldings(): Promise<ExtendedApiResponse<Balance>> {
-    return this.makeRequest<Balance>("/api/v1/holdings");
+    return this.makeRequest<Balance>("/api/v1/holdings", true);
   }
 
   /**
    * Initiate a withdrawal from Extended Exchange
+   * Returns data as number | string to preserve precision for large integers
    */
   async withdraw(
-    request: WithdrawRequest
-  ): Promise<ExtendedApiResponse<number>> {
-    return this.makeRequest<number>("/api/v1/withdraw", {
+    request: WithdrawRequest,
+  ): Promise<ExtendedApiResponse<number | string>> {
+    return this.makeRequest<number | string>("/api/v1/withdraw", false, {
       method: "POST",
       body: JSON.stringify(request),
     });
@@ -181,7 +361,7 @@ export class ExtendedWrapper {
       };
     }>
   > {
-    return this.makeRequest("/api/v1/withdraw/sign", {
+    return this.makeRequest("/api/v1/withdraw/sign", false, {
       method: "POST",
       body: JSON.stringify(request),
     });
@@ -191,25 +371,24 @@ export class ExtendedWrapper {
    * Cancel an existing order
    */
   async cancelOrder(
-    request: CancelOrderRequest
+    request: CancelOrderRequest,
   ): Promise<ExtendedApiResponse<{}>> {
-    return this.makeRequest<{}>("/api/v1/orders/cancel", {
+    return this.makeRequest<{}>("/api/v1/orders/cancel", false, {
       method: "POST",
       body: JSON.stringify(request),
     });
   }
 
-
   /**
    * Get all open orders
    */
   async getOpenOrders(
-    marketName?: string
+    marketName?: string,
   ): Promise<ExtendedApiResponse<OpenOrder[]>> {
     const endpoint = marketName
       ? `/api/v1/marketOrders/${marketName}`
       : "/api/v1/marketOrders";
-    return this.makeRequest<OpenOrder[]>(endpoint,{
+    return this.makeRequest<OpenOrder[]>(endpoint, false, {
       method: "GET",
       headers: {
         "Content-Type": "application/json",
@@ -223,9 +402,9 @@ export class ExtendedWrapper {
    * @returns
    */
   async updateLeverage(
-    request: UpdateLeverageRequest
+    request: UpdateLeverageRequest,
   ): Promise<ExtendedApiResponse<{}>> {
-    return this.makeRequest<{}>("/api/v1/leverage", {
+    return this.makeRequest<{}>("/api/v1/leverage", false, {
       method: "POST",
       body: JSON.stringify(request),
     });
@@ -243,7 +422,7 @@ export class ExtendedWrapper {
       endTime?: number;
       cursor?: number;
       limit?: number;
-    } = {}
+    } = {},
   ): Promise<ExtendedApiResponse<AssetOperation[]>> {
     const params = new URLSearchParams();
 
@@ -268,14 +447,14 @@ export class ExtendedWrapper {
       queryString ? `?${queryString}` : ""
     }`;
 
-    return this.makeRequest<AssetOperation[]>(endpoint);
+    return this.makeRequest<AssetOperation[]>(endpoint, false);
   }
 
   /**
    * Health check endpoint
    */
   async healthCheck(): Promise<ExtendedApiResponse<MarketStats>> {
-    return this.makeRequest<MarketStats>("/api/v1/health");
+    return this.makeRequest<MarketStats>("/api/v1/health", false);
   }
 
   /**
@@ -286,11 +465,12 @@ export class ExtendedWrapper {
     amount: string,
     price: string,
     options: {
-      postOnly?: boolean;
-      previousOrderId?: number;
-      externalId?: string;
-      timeInForce?: TimeInForce;
-    } = {}
+      post_only?: boolean;
+      reduce_only?: boolean;
+      previous_order_id?: number;
+      external_id?: string;
+      time_in_force?: TimeInForce;
+    } = {},
   ): Promise<ExtendedApiResponse<PlacedOrder>> {
     return this.createOrder({
       market_name: marketName,
@@ -301,13 +481,13 @@ export class ExtendedWrapper {
     });
   }
 
-   /**
+  /**
    * Get order by ID
    * @param orderId - The ID of the order to get
    * @returns The order
    */
-   async getOrderById(orderId: number): Promise<ExtendedApiResponse<OpenOrder>> {
-    return this.makeRequest<OpenOrder>(`/api/v1/orderId/${orderId}`);
+  async getOrderById(orderId: number): Promise<ExtendedApiResponse<OpenOrder>> {
+    return this.makeRequest<OpenOrder>(`/api/v1/orderId/${orderId}`, false);
   }
 
   /**
@@ -318,11 +498,12 @@ export class ExtendedWrapper {
     amount: string,
     price: string,
     options: {
-      postOnly?: boolean;
-      previousOrderId?: number;
-      externalId?: string;
-      timeInForce?: TimeInForce;
-    } = {}
+      post_only?: boolean;
+      reduce_only?: boolean;
+      previous_order_id?: number;
+      external_id?: string;
+      time_in_force?: TimeInForce;
+    } = {},
   ): Promise<ExtendedApiResponse<PlacedOrder>> {
     return this.createOrder({
       market_name: marketName,
@@ -337,7 +518,7 @@ export class ExtendedWrapper {
    * Get positions for a specific market
    */
   async getPositionsForMarket(
-    marketName: string
+    marketName: string,
   ): Promise<ExtendedApiResponse<Position[]>> {
     return this.getPositions(marketName);
   }
@@ -346,7 +527,7 @@ export class ExtendedWrapper {
    * Get open orders for a specific market
    */
   async getOpenOrdersForMarket(
-    marketName: string
+    marketName: string,
   ): Promise<ExtendedApiResponse<OpenOrder[]>> {
     return this.getOpenOrders(marketName);
   }
@@ -357,20 +538,25 @@ export class ExtendedWrapper {
   async cancelOrderById(orderId: number): Promise<ExtendedApiResponse<{}>> {
     return this.cancelOrder({ order_id: orderId });
   }
-  
+
   /**
    * Get order history for a specific market
    * @param marketName - The name of the market to get order history for
    * @returns The order history for the specified market
    */
-  async getOrderHistory(marketName: string): Promise<ExtendedApiResponse<OpenOrder[]>> {
-    return this.makeRequest<OpenOrder[]>(`/api/v1/marketOrders/${marketName}`);
+  async getOrderHistory(
+    marketName: string,
+  ): Promise<ExtendedApiResponse<OpenOrder[]>> {
+    return this.makeRequest<OpenOrder[]>(`/api/v1/marketOrders/${marketName}`, false);
   }
 
   /**
    * Withdraw USDC (convenience method)
+   * Returns data as number | string to preserve precision for large integers
    */
-  async withdrawUSDC(amount: string): Promise<ExtendedApiResponse<number>> {
+  async withdrawUSDC(
+    amount: string,
+  ): Promise<ExtendedApiResponse<number | string>> {
     return this.withdraw({ amount, asset: "USDC" });
   }
 
@@ -381,15 +567,45 @@ export class ExtendedWrapper {
    */
   async getFundingRates(
     marketName: string,
-    side: string
+    side: string,
+    startTime?: number,
+    endTime?: number,
+    // in epoch  milliseconds
   ): Promise<ExtendedApiResponse<FundingRate[]>> {
-    return this.makeRequest<FundingRate[]>(
+    const endTimeParam = endTime !== undefined ? `&end_time=${endTime}` : "";
+    const startTimeParam =
+      startTime !== undefined ? `&start_time=${startTime}` : "";
+    const response = await this.makeRequest<FundingRate[]>(
       `/api/v1/markets/funding-rates?market_name=${encodeURIComponent(
-        marketName
-      )}&side=${encodeURIComponent(side)}`
+        marketName,
+      )}&side=${encodeURIComponent(side)}${startTimeParam}${endTimeParam}`,
+      true
     );
+    return response;
   }
 
+  /**
+   * Get funding payments for a specific market.
+   */
+  async getUserFundingPayments(
+    marketName: string,
+    side: string,
+    startTime: number,
+    limit?: number,
+    cursor?: number,
+  ): Promise<ExtendedApiResponse<FundingPayment[]>> {
+    const params = new URLSearchParams();
+    params.append("start_time", String(startTime));
+    params.append("market_names", marketName);
+    params.append("side", side);
+    if (limit !== undefined) params.append("limit", String(limit));
+    if (cursor !== undefined) params.append("cursor", String(cursor));
+
+    return this.makeRequest<FundingPayment[]>(
+      `/api/v1/account/funding-payments?${params.toString()}`,
+      true,
+    );
+  }
 }
 
 export default ExtendedWrapper;

package/src/modules/apollo-client-config.ts

@@ -0,0 +1,28 @@
+import { ApolloClient, InMemoryCache } from '@apollo/client';
+import { IConfig } from '@/interfaces';
+
+/**
+ * Creates an Apollo Client instance configured for the appropriate environment
+ * @param config - The application config containing network and stage information
+ * @returns Configured Apollo Client instance
+ */
+export function createApolloClient(config: IConfig) {
+  // Determine the URI based on the environment
+  const uri = config.stage === 'production' 
+    ? 'https://api.troves.fi/' 
+    : 'http://localhost:4000';
+
+  return new ApolloClient({
+    uri,
+    cache: new InMemoryCache(),
+  });
+}
+
+// Default client for backward compatibility
+const apolloClient = new ApolloClient({
+  uri: 'https://api.troves.fi/',
+  cache: new InMemoryCache(),
+});
+
+export default apolloClient;
+

package/src/modules/avnu.ts

@@ -37,7 +37,7 @@ export class AvnuWrapper {
     excludeSources = ['Haiko(Solvers)']
   ): Promise<Quote> {
     const MAX_RETRY = 5;
-    logger.verbose(`${AvnuWrapper.name}: getQuotes => Getting quotes for ${fromToken} -> ${toToken}, amount: ${amountWei}, taker: ${taker}, retry: ${retry}`);
+    // logger.verbose(`${AvnuWrapper.name}: getQuotes => Getting quotes for ${fromToken} -> ${toToken}, amount: ${amountWei}, taker: ${taker}, retry: ${retry}`);
     const params: any = {
       sellTokenAddress: fromToken,
       buyTokenAddress: toToken,
@@ -100,9 +100,9 @@ export class AvnuWrapper {
     // swapInfo as expected by the strategy
     // fallback, max 1% slippage
     const _minAmount = minAmount || (quote.buyAmount * 95n / 100n).toString();
-    logger.verbose(`${AvnuWrapper.name}: getSwapInfo => sellToken: ${quote.sellTokenAddress}, sellAmount: ${quote.sellAmount}`);
-    logger.verbose(`${AvnuWrapper.name}: getSwapInfo => buyToken: ${quote.buyTokenAddress}`);
-    logger.verbose(`${AvnuWrapper.name}: getSwapInfo => buyAmount: ${quote.buyAmount}, minAmount: ${_minAmount}`);
+    // logger.verbose(`${AvnuWrapper.name}: getSwapInfo => sellToken: ${quote.sellTokenAddress}, sellAmount: ${quote.sellAmount}`);
+    // logger.verbose(`${AvnuWrapper.name}: getSwapInfo => buyToken: ${quote.buyTokenAddress}`);
+    // logger.verbose(`${AvnuWrapper.name}: getSwapInfo => buyAmount: ${quote.buyAmount}, minAmount: ${_minAmount}`);
     const swapInfo: SwapInfo = {
       token_from_address: quote.sellTokenAddress,
       token_from_amount: uint256.bnToUint256(quote.sellAmount),

package/src/modules/ekubo-pricer.ts

@@ -0,0 +1,79 @@
+import { Contract, RpcProvider, BlockIdentifier } from "starknet";
+import EkuboPricerAbi from '@/data/ekubo-price-fethcer.abi.json';
+import { PricerBase } from "./pricerBase";
+import { IConfig, TokenInfo } from "@/interfaces";
+import { PriceInfo } from "./pricer";
+
+export class EkuboPricer extends PricerBase {
+    EKUBO_PRICE_FETCHER_ADDRESS = '0x04946fb4ad5237d97bbb1256eba2080c4fe1de156da6a7f83e3b4823bb6d7da1';
+    readonly contract: Contract;
+    private readonly USDC_ADDRESS = '0x053c91253bc9682c04929ca02ed00b3e423f6710d2ee7e0d5ebb06f3ecf368a8';
+    private readonly USDC_DECIMALS = 6;
+
+    constructor(config: IConfig, tokens: TokenInfo[]) {
+        super(config, tokens);
+        this.contract = new Contract({
+            abi: EkuboPricerAbi, 
+            address: this.EKUBO_PRICE_FETCHER_ADDRESS, 
+            providerOrAccount: config.provider as RpcProvider
+        });
+    }
+
+    private div2Power128(num: bigint): number {
+        return Number((num * BigInt(1e18)) / BigInt(2 ** 128)) / 1e18;
+    }
+
+    async getPrice(tokenAddr: string, blockIdentifier: BlockIdentifier = 'latest'): Promise<PriceInfo> {
+        if (!tokenAddr) {
+            throw new Error(`EkuboPricer:getPrice - no token`);
+        }
+
+        // get_prices arguments in order:
+        // - quote_token: USDC address (quote token for price calculation)
+        // - base_tokens: array containing the base token address/addresses
+        // - period: time period in seconds for TWAP (3600 = 1 hour)
+        // - min_token: minimum token amount threshold (min liquidity) in 6 Decimals = 1000000)
+        const result: any = await this.contract.call(
+            'get_prices',
+            [this.USDC_ADDRESS, [tokenAddr], 3600, 1000000],
+            { blockIdentifier }
+        );
+
+        if (!result || result.length === 0) {
+            throw new Error(`EkuboPricer: No price result returned for ${tokenAddr}`);
+        }
+
+        const priceResult = result[0];
+        
+        if (!priceResult?.variant?.Price) {
+            const variant = priceResult?.variant ? Object.keys(priceResult.variant)[0] : 'Unknown';
+            throw new Error(`EkuboPricer: Price fetch failed with variant: ${variant}`);
+        }
+
+        const rawPrice = typeof priceResult.variant.Price === 'string' 
+            ? BigInt(priceResult.variant.Price) 
+            : priceResult.variant.Price;
+
+        // Get token info to determine decimals from configured tokens
+        const tokenInfo = this.tokens.find(t => 
+            t.address.address.toLowerCase() === tokenAddr.toLowerCase()
+        );
+        
+        if (!tokenInfo) {
+            throw new Error(`Token ${tokenAddr} not found in global tokens`);
+        }
+
+        // Convert from x128 format
+        const priceAfterX128 = this.div2Power128(rawPrice);
+        
+        // Adjust for token decimals
+        const decimalAdjustment = 10 ** (tokenInfo.decimals - this.USDC_DECIMALS);
+        const price = priceAfterX128 * decimalAdjustment;
+
+        return {
+            price,
+            timestamp: new Date()
+        };
+    }
+}
+