@crypticdot/defituna-api 1.1.28

package/dist/index.mjs

@@ -0,0 +1,493 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/client/client.ts
+import camelcaseKeys from "camelcase-keys";
+
+// src/client/schemas.ts
+var schemas_exports = {};
+__export(schemas_exports, {
+  LendingPosition: () => LendingPosition,
+  LimitOrder: () => LimitOrder,
+  LimitOrderState: () => LimitOrderState,
+  LimitOrderStateSchema: () => LimitOrderStateSchema,
+  Market: () => Market,
+  Mint: () => Mint,
+  NotificationAction: () => NotificationAction,
+  NotificationActionSchema: () => NotificationActionSchema,
+  NotificationEntity: () => NotificationEntity,
+  NotificationEntitySchema: () => NotificationEntitySchema,
+  OrderBook: () => OrderBook,
+  OrderBookEntry: () => OrderBookEntry,
+  OrderBookNotification: () => OrderBookNotification,
+  OrderBookNotificationMeta: () => OrderBookNotificationMeta,
+  Pool: () => Pool,
+  PoolPriceCandle: () => PoolPriceCandle,
+  PoolPriceUpdate: () => PoolPriceUpdate,
+  PoolPriceUpdateNotification: () => PoolPriceUpdateNotification,
+  PoolProvider: () => PoolProvider,
+  PoolProviderSchema: () => PoolProviderSchema,
+  PoolSwap: () => PoolSwap,
+  PoolSwapNotification: () => PoolSwapNotification,
+  PoolTicks: () => PoolTicks,
+  Tick: () => Tick,
+  TokenOraclePrice: () => TokenOraclePrice,
+  TunaPosition: () => TunaPosition,
+  TunaPositionState: () => TunaPositionState,
+  TunaPositionStateSchema: () => TunaPositionStateSchema,
+  Vault: () => Vault
+});
+import { z } from "zod";
+var amountWithoutUsd = z.object({
+  amount: z.coerce.bigint()
+});
+var amountWithUsd = z.object({
+  amount: z.coerce.bigint(),
+  usd: z.number()
+});
+var tokensPnl = z.object({
+  amount: z.coerce.bigint(),
+  bps: z.number()
+});
+var usdPnl = z.object({
+  amount: z.number(),
+  bps: z.number()
+});
+var NotificationEntity = {
+  POOL_SWAP: "pool_swap",
+  POOL_PRICE: "pool_price",
+  ORDER_BOOK: "order_book"
+};
+var NotificationAction = {
+  CREATE: "create",
+  UPDATE: "update"
+};
+var PoolProvider = {
+  ORCA: "orca",
+  FUSION: "fusion"
+};
+var TunaPositionState = {
+  OPEN: "open",
+  LIQUIDATED: "liquidated",
+  CLOSED_BY_LIMIT_ORDER: "closed_by_limit_order",
+  CLOSED: "closed"
+};
+var LimitOrderState = {
+  OPEN: "open",
+  PARTIALLY_FILLED: "partially_filled",
+  FILLED: "filled",
+  COMPLETE: "complete",
+  CANCELLED: "cancelled"
+};
+var NotificationEntitySchema = z.enum([NotificationEntity.POOL_SWAP, ...Object.values(NotificationEntity)]);
+var NotificationActionSchema = z.enum([NotificationAction.CREATE, ...Object.values(NotificationAction)]);
+var PoolProviderSchema = z.enum([PoolProvider.ORCA, ...Object.values(PoolProvider)]);
+var TunaPositionStateSchema = z.enum([TunaPositionState.OPEN, ...Object.values(TunaPositionState)]);
+var LimitOrderStateSchema = z.enum([LimitOrderState.OPEN, ...Object.values(LimitOrderState)]);
+var Mint = z.object({
+  symbol: z.string(),
+  mint: z.string(),
+  logo: z.string(),
+  decimals: z.number()
+});
+var Market = z.object({
+  address: z.string(),
+  addressLookupTable: z.string(),
+  poolAddress: z.string(),
+  poolFeeRate: z.number(),
+  provider: PoolProviderSchema,
+  maxLeverage: z.number(),
+  protocolFee: z.number(),
+  protocolFeeOnCollateral: z.number(),
+  liquidationFee: z.number(),
+  liquidationThreshold: z.number(),
+  limitOrderExecutionFee: z.number(),
+  borrowedFundsA: amountWithUsd,
+  borrowedFundsB: amountWithUsd,
+  availableBorrowA: amountWithUsd,
+  availableBorrowB: amountWithUsd,
+  borrowLimitA: amountWithUsd,
+  borrowLimitB: amountWithUsd,
+  disabled: z.boolean()
+});
+var TokenOraclePrice = z.object({
+  mint: z.string(),
+  price: z.coerce.bigint(),
+  decimals: z.number(),
+  time: z.coerce.date()
+});
+var Vault = z.object({
+  address: z.string(),
+  mint: z.string(),
+  depositedFunds: amountWithUsd,
+  borrowedFunds: amountWithUsd,
+  supplyLimit: amountWithUsd,
+  borrowedShares: z.coerce.bigint(),
+  depositedShares: z.coerce.bigint(),
+  supplyApy: z.number(),
+  borrowApy: z.number(),
+  utilization: z.number(),
+  pythOracleFeedId: z.string(),
+  pythOraclePriceUpdate: z.string()
+});
+var Pool = z.object({
+  address: z.string(),
+  provider: PoolProviderSchema,
+  tokenAMint: z.string(),
+  tokenBMint: z.string(),
+  tokenAVault: z.string(),
+  tokenBVault: z.string(),
+  tvlUsdc: z.coerce.number(),
+  tickSpacing: z.number(),
+  feeRate: z.number(),
+  protocolFeeRate: z.number(),
+  liquidity: z.coerce.bigint(),
+  sqrtPrice: z.coerce.bigint(),
+  tickCurrentIndex: z.number(),
+  stats: z.object({
+    "24h": z.object({
+      volume: z.coerce.number(),
+      fees: z.coerce.number(),
+      rewards: z.coerce.number(),
+      yieldOverTvl: z.coerce.number()
+    }),
+    "7d": z.object({
+      volume: z.coerce.number(),
+      fees: z.coerce.number(),
+      rewards: z.coerce.number(),
+      yieldOverTvl: z.coerce.number()
+    }),
+    "30d": z.object({
+      volume: z.coerce.number(),
+      fees: z.coerce.number(),
+      rewards: z.coerce.number(),
+      yieldOverTvl: z.coerce.number()
+    })
+  })
+});
+var Tick = z.object({
+  index: z.number(),
+  liquidity: z.coerce.bigint()
+});
+var PoolTicks = z.object({
+  tickSpacing: z.number(),
+  ticks: Tick.array()
+});
+var LendingPosition = z.object({
+  address: z.string(),
+  authority: z.string(),
+  mint: z.string(),
+  vault: z.string(),
+  shares: z.coerce.bigint(),
+  funds: amountWithUsd,
+  earned: amountWithUsd
+});
+var TunaPosition = z.object({
+  address: z.string(),
+  authority: z.string(),
+  version: z.number(),
+  state: TunaPositionStateSchema,
+  positionMint: z.string(),
+  liquidity: z.coerce.bigint(),
+  tickLowerIndex: z.number(),
+  tickUpperIndex: z.number(),
+  tickEntryIndex: z.number(),
+  tickStopLossIndex: z.number(),
+  tickTakeProfitIndex: z.number(),
+  swapToTokenOnLimitOrder: z.number(),
+  flags: z.number(),
+  pool: z.string(),
+  poolSqrtPrice: z.coerce.bigint(),
+  depositedCollateralA: amountWithoutUsd,
+  depositedCollateralB: amountWithoutUsd,
+  depositedCollateralUsd: z.object({
+    amount: z.number()
+  }),
+  loanFundsA: amountWithUsd,
+  loanFundsB: amountWithUsd,
+  currentLoanA: amountWithUsd,
+  currentLoanB: amountWithUsd,
+  leftoversA: amountWithUsd,
+  leftoversB: amountWithUsd,
+  yieldA: amountWithUsd,
+  yieldB: amountWithUsd,
+  compoundedYieldA: amountWithUsd,
+  compoundedYieldB: amountWithUsd,
+  totalA: amountWithUsd,
+  totalB: amountWithUsd,
+  pnlA: tokensPnl,
+  pnlB: tokensPnl,
+  pnlUsd: usdPnl,
+  openedAt: z.coerce.date(),
+  updatedAtSlot: z.coerce.bigint()
+});
+var PoolSwap = z.object({
+  id: z.string(),
+  amountIn: z.coerce.bigint(),
+  amountOut: z.coerce.bigint(),
+  aToB: z.boolean(),
+  pool: z.string(),
+  time: z.coerce.date()
+});
+var OrderBookEntry = z.object({
+  concentratedAmount: z.coerce.bigint(),
+  concentratedAmountQuote: z.coerce.bigint(),
+  concentratedTotal: z.coerce.bigint(),
+  concentratedTotalQuote: z.coerce.bigint(),
+  limitAmount: z.coerce.bigint(),
+  limitAmountQuote: z.coerce.bigint(),
+  limitTotal: z.coerce.bigint(),
+  limitTotalQuote: z.coerce.bigint(),
+  price: z.number(),
+  askSide: z.boolean()
+});
+var PoolPriceUpdate = z.object({
+  pool: z.string(),
+  price: z.number(),
+  sqrtPrice: z.coerce.bigint(),
+  time: z.coerce.date()
+});
+var OrderBook = z.object({
+  entries: OrderBookEntry.array(),
+  poolPrice: z.number()
+});
+var LimitOrder = z.object({
+  address: z.string(),
+  mint: z.string(),
+  pool: z.string(),
+  state: LimitOrderStateSchema,
+  aToB: z.boolean(),
+  tickIndex: z.number(),
+  fillRatio: z.number(),
+  openTxSignature: z.string(),
+  closeTxSignature: z.string().nullable(),
+  amount: amountWithUsd,
+  openedAt: z.coerce.date(),
+  closedAt: z.coerce.date().nullable()
+});
+var PoolPriceCandle = z.object({
+  time: z.number(),
+  open: z.number(),
+  close: z.number(),
+  high: z.number(),
+  low: z.number()
+});
+var createNotificationSchema = (dataSchema, metaSchema) => z.object({
+  entity: NotificationEntitySchema,
+  action: NotificationActionSchema,
+  data: dataSchema,
+  id: z.string(),
+  authority: z.nullable(z.string()),
+  ...metaSchema ? { meta: metaSchema } : { meta: z.undefined().nullable() }
+});
+var OrderBookNotificationMeta = z.object({
+  pool: z.string(),
+  priceStep: z.number(),
+  inverted: z.boolean()
+});
+var PoolSwapNotification = createNotificationSchema(PoolSwap);
+var PoolPriceUpdateNotification = createNotificationSchema(PoolPriceUpdate);
+var OrderBookNotification = createNotificationSchema(OrderBook, OrderBookNotificationMeta);
+
+// src/client/client.ts
+var DEFAULT_TIMEOUT = 5e3;
+var DEFAULT_HTTP_RETRIES = 3;
+var ProviderFilter = /* @__PURE__ */ ((ProviderFilter2) => {
+  ProviderFilter2["ORCA"] = "orca";
+  ProviderFilter2["FUSION"] = "fusion";
+  ProviderFilter2["ALL"] = "all";
+  return ProviderFilter2;
+})(ProviderFilter || {});
+var TunaApiClient = class {
+  get baseURL() {
+    return this._baseURL;
+  }
+  get timeout() {
+    return this._timeout;
+  }
+  get httpRetries() {
+    return this._httpRetries;
+  }
+  get headers() {
+    return this._headers;
+  }
+  constructor(baseURL, config) {
+    this._baseURL = baseURL;
+    this._timeout = config?.timeout ?? DEFAULT_TIMEOUT;
+    this._httpRetries = config?.httpRetries ?? DEFAULT_HTTP_RETRIES;
+    this._headers = config?.headers ?? {};
+  }
+  setConfig(config) {
+    if (config.baseURL) {
+      this._baseURL = config.baseURL;
+    }
+    this._timeout = config?.timeout ?? DEFAULT_TIMEOUT;
+    this._httpRetries = config?.httpRetries ?? DEFAULT_HTTP_RETRIES;
+    this._headers = config?.headers ?? {};
+  }
+  async httpRequest(url, schema, options, retries = this.httpRetries, backoff = 100 + Math.floor(Math.random() * 100)) {
+    try {
+      const controller = new AbortController();
+      const abort = setTimeout(() => {
+        controller.abort();
+      }, this.timeout);
+      const signal = options?.signal || controller.signal;
+      const response = await fetch(url, {
+        ...options,
+        signal,
+        headers: { ...this.headers, ...options?.headers }
+      });
+      clearTimeout(abort);
+      if (!response.ok) {
+        const errorBody = await response.json();
+        throw errorBody;
+      }
+      const data = await response.json();
+      const transformed = camelcaseKeys(data, { deep: true, exclude: ["24h", "7d", "30d"] });
+      return schema.parse(transformed.data);
+    } catch (error) {
+      if (retries > 0 && !(error instanceof Error && error.name === "AbortError")) {
+        await new Promise((resolve) => setTimeout(resolve, backoff));
+        return this.httpRequest(url, schema, options, retries - 1, backoff * 2);
+      }
+      throw error;
+    }
+  }
+  /* Endpoints */
+  async getMints() {
+    const url = this.buildURL("mints");
+    return await this.httpRequest(url.toString(), Mint.array());
+  }
+  async getMint(mintAddress) {
+    const url = this.buildURL(`mints/${mintAddress}`);
+    return await this.httpRequest(url.toString(), Mint);
+  }
+  async getMarkets() {
+    const url = this.buildURL("markets");
+    return await this.httpRequest(url.toString(), Market.array());
+  }
+  async getMarket(marketAddress) {
+    const url = this.buildURL(`markets/${marketAddress}`);
+    return await this.httpRequest(url.toString(), Market);
+  }
+  async getOraclePrices() {
+    const url = this.buildURL("oracle-prices");
+    return await this.httpRequest(url.toString(), TokenOraclePrice.array());
+  }
+  async getOraclePrice(mintAddress) {
+    const url = this.buildURL(`oracle-prices/${mintAddress}`);
+    return await this.httpRequest(url.toString(), TokenOraclePrice);
+  }
+  async getVaults() {
+    const url = this.buildURL("vaults");
+    return await this.httpRequest(url.toString(), Vault.array());
+  }
+  async getVault(vaultAddress) {
+    const url = this.buildURL(`vaults/${vaultAddress}`);
+    return await this.httpRequest(url.toString(), Vault);
+  }
+  async getPools(providerFilter) {
+    const url = this.buildURL("pools");
+    if (providerFilter && providerFilter !== "all" /* ALL */) {
+      this.appendUrlSearchParams(url, { provider: providerFilter });
+    }
+    return await this.httpRequest(url.toString(), Pool.array());
+  }
+  async getPool(address) {
+    const url = this.buildURL(`pools/${address}`);
+    return await this.httpRequest(url.toString(), Pool);
+  }
+  async getPoolTicks(poolAddress) {
+    const url = this.buildURL(`pools/${poolAddress}/ticks`);
+    return await this.httpRequest(url.toString(), PoolTicks);
+  }
+  async getPoolSwaps(poolAddress) {
+    const url = this.buildURL(`pools/${poolAddress}/swaps`);
+    return await this.httpRequest(url.toString(), PoolSwap.array());
+  }
+  async getPoolOrderBook(poolAddress, priceStep, inverted) {
+    const url = this.buildURL(`pools/${poolAddress}/order-book`);
+    this.appendUrlSearchParams(url, { price_step: priceStep.toString() });
+    if (inverted) {
+      this.appendUrlSearchParams(url, { inverted: inverted.toString() });
+    }
+    return await this.httpRequest(url.toString(), OrderBook);
+  }
+  async getPoolPriceCandles(poolAddress, options) {
+    const { from, to, interval, candles } = options;
+    const url = this.buildURL(`pools/${poolAddress}/candles`);
+    this.appendUrlSearchParams(url, {
+      from: from.toISOString(),
+      to: to.toISOString(),
+      candles: candles.toString(),
+      interval
+    });
+    return await this.httpRequest(url.toString(), PoolPriceCandle.array());
+  }
+  async getUserLendingPositions(userAddress) {
+    const url = this.buildURL(`users/${userAddress}/lending-positions`);
+    return await this.httpRequest(url.toString(), LendingPosition.array());
+  }
+  async getUserLendingPositionByAddress(userAddress, lendingPositionAddress) {
+    const url = this.buildURL(`users/${userAddress}/lending-positions/${lendingPositionAddress}`);
+    return await this.httpRequest(url.toString(), LendingPosition);
+  }
+  async getUserTunaPositions(userAddress) {
+    const url = this.buildURL(`users/${userAddress}/tuna-positions`);
+    return await this.httpRequest(url.toString(), TunaPosition.array());
+  }
+  async getUserTunaPositionByAddress(userAddress, tunaPositionAddress) {
+    const url = this.buildURL(`users/${userAddress}/tuna-positions/${tunaPositionAddress}`);
+    return await this.httpRequest(url.toString(), TunaPosition);
+  }
+  async getUserLimitOrders(userAddress, poolFilter) {
+    const url = this.buildURL(`users/${userAddress}/limit-orders`);
+    if (poolFilter) {
+      this.appendUrlSearchParams(url, { pool: poolFilter });
+    }
+    return await this.httpRequest(url.toString(), LimitOrder.array());
+  }
+  async getUserLimitOrderByAddress(userAddress, limitOrderAddress) {
+    const url = this.buildURL(`users/${userAddress}/limit-orders/${limitOrderAddress}`);
+    return await this.httpRequest(url.toString(), LimitOrder);
+  }
+  async getPoolUpdatesStream(poolAddress, priceStep, inverted) {
+    const url = this.buildURL(`stream`);
+    this.appendUrlSearchParams(url, { pool: poolAddress });
+    if (priceStep) {
+      this.appendUrlSearchParams(url, { price_step: priceStep.toString() });
+    }
+    if (inverted) {
+      this.appendUrlSearchParams(url, { inverted: inverted.toString() });
+    }
+    return new EventSource(url.toString());
+  }
+  /* Utility functions */
+  buildURL(endpoint) {
+    return new URL(
+      `./v1/${endpoint}`,
+      // We ensure the `baseURL` ends with a `/` so that URL doesn't resolve the
+      // path relative to the parent.
+      `${this.baseURL}${this.baseURL.endsWith("/") ? "" : "/"}`
+    );
+  }
+  appendUrlSearchParams(url, params) {
+    Object.entries(params).forEach(([key, value]) => {
+      if (value !== void 0) {
+        url.searchParams.append(key, String(value));
+      }
+    });
+  }
+};
+export {
+  NotificationAction,
+  NotificationEntity,
+  PoolProvider,
+  ProviderFilter,
+  TunaApiClient,
+  TunaPositionState,
+  schemas_exports as schemas
+};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@crypticdot/defituna-api",
+  "version": "1.1.28",
+  "private": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "devDependencies": {
+    "@crypticdot/defituna-client": "^2.0.6",
+    "@crypticdot/eslint-config": "^1.0.0",
+    "@crypticdot/prettier-config": "^1.0.0",
+    "@crypticdot/typescript-config": "^1.0.0",
+    "@solana/kit": "^2.1.0",
+    "@types/node": "^22.13.14",
+    "decimal.js": "^10.5.0",
+    "dotenv": "^16.4.7",
+    "eslint": "^8.57.0",
+    "eventsource": "^3.0.6",
+    "express": "^4.21.2",
+    "tsup": "^8.3.5",
+    "typescript": "5.8.3",
+    "vite-tsconfig-paths": "^5.1.4",
+    "vitest": "^3.0.9"
+  },
+  "dependencies": {
+    "camelcase-keys": "^9.1.3",
+    "zod": "^3.24.1"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "eslint": "eslint \"**/*.ts\"",
+    "eslint:fix": "eslint \"**/*.ts\" --fix",
+    "type-check": "tsc -p .",
+    "lint": "pnpm eslint && pnpm type-check",
+    "test": "vitest run --disable-console-intercept",
+    "test:start-server": "node scripts/startTestsServer.mjs",
+    "test:watch": "vitest watch"
+  }
+}