@crypticdot/defituna-api 1.1.28

package/dist/index.js

@@ -0,0 +1,529 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  NotificationAction: () => NotificationAction,
+  NotificationEntity: () => NotificationEntity,
+  PoolProvider: () => PoolProvider,
+  ProviderFilter: () => ProviderFilter,
+  TunaApiClient: () => TunaApiClient,
+  TunaPositionState: () => TunaPositionState,
+  schemas: () => schemas_exports
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client/client.ts
+var import_camelcase_keys = __toESM(require("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
+});
+var import_zod = require("zod");
+var amountWithoutUsd = import_zod.z.object({
+  amount: import_zod.z.coerce.bigint()
+});
+var amountWithUsd = import_zod.z.object({
+  amount: import_zod.z.coerce.bigint(),
+  usd: import_zod.z.number()
+});
+var tokensPnl = import_zod.z.object({
+  amount: import_zod.z.coerce.bigint(),
+  bps: import_zod.z.number()
+});
+var usdPnl = import_zod.z.object({
+  amount: import_zod.z.number(),
+  bps: import_zod.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 = import_zod.z.enum([NotificationEntity.POOL_SWAP, ...Object.values(NotificationEntity)]);
+var NotificationActionSchema = import_zod.z.enum([NotificationAction.CREATE, ...Object.values(NotificationAction)]);
+var PoolProviderSchema = import_zod.z.enum([PoolProvider.ORCA, ...Object.values(PoolProvider)]);
+var TunaPositionStateSchema = import_zod.z.enum([TunaPositionState.OPEN, ...Object.values(TunaPositionState)]);
+var LimitOrderStateSchema = import_zod.z.enum([LimitOrderState.OPEN, ...Object.values(LimitOrderState)]);
+var Mint = import_zod.z.object({
+  symbol: import_zod.z.string(),
+  mint: import_zod.z.string(),
+  logo: import_zod.z.string(),
+  decimals: import_zod.z.number()
+});
+var Market = import_zod.z.object({
+  address: import_zod.z.string(),
+  addressLookupTable: import_zod.z.string(),
+  poolAddress: import_zod.z.string(),
+  poolFeeRate: import_zod.z.number(),
+  provider: PoolProviderSchema,
+  maxLeverage: import_zod.z.number(),
+  protocolFee: import_zod.z.number(),
+  protocolFeeOnCollateral: import_zod.z.number(),
+  liquidationFee: import_zod.z.number(),
+  liquidationThreshold: import_zod.z.number(),
+  limitOrderExecutionFee: import_zod.z.number(),
+  borrowedFundsA: amountWithUsd,
+  borrowedFundsB: amountWithUsd,
+  availableBorrowA: amountWithUsd,
+  availableBorrowB: amountWithUsd,
+  borrowLimitA: amountWithUsd,
+  borrowLimitB: amountWithUsd,
+  disabled: import_zod.z.boolean()
+});
+var TokenOraclePrice = import_zod.z.object({
+  mint: import_zod.z.string(),
+  price: import_zod.z.coerce.bigint(),
+  decimals: import_zod.z.number(),
+  time: import_zod.z.coerce.date()
+});
+var Vault = import_zod.z.object({
+  address: import_zod.z.string(),
+  mint: import_zod.z.string(),
+  depositedFunds: amountWithUsd,
+  borrowedFunds: amountWithUsd,
+  supplyLimit: amountWithUsd,
+  borrowedShares: import_zod.z.coerce.bigint(),
+  depositedShares: import_zod.z.coerce.bigint(),
+  supplyApy: import_zod.z.number(),
+  borrowApy: import_zod.z.number(),
+  utilization: import_zod.z.number(),
+  pythOracleFeedId: import_zod.z.string(),
+  pythOraclePriceUpdate: import_zod.z.string()
+});
+var Pool = import_zod.z.object({
+  address: import_zod.z.string(),
+  provider: PoolProviderSchema,
+  tokenAMint: import_zod.z.string(),
+  tokenBMint: import_zod.z.string(),
+  tokenAVault: import_zod.z.string(),
+  tokenBVault: import_zod.z.string(),
+  tvlUsdc: import_zod.z.coerce.number(),
+  tickSpacing: import_zod.z.number(),
+  feeRate: import_zod.z.number(),
+  protocolFeeRate: import_zod.z.number(),
+  liquidity: import_zod.z.coerce.bigint(),
+  sqrtPrice: import_zod.z.coerce.bigint(),
+  tickCurrentIndex: import_zod.z.number(),
+  stats: import_zod.z.object({
+    "24h": import_zod.z.object({
+      volume: import_zod.z.coerce.number(),
+      fees: import_zod.z.coerce.number(),
+      rewards: import_zod.z.coerce.number(),
+      yieldOverTvl: import_zod.z.coerce.number()
+    }),
+    "7d": import_zod.z.object({
+      volume: import_zod.z.coerce.number(),
+      fees: import_zod.z.coerce.number(),
+      rewards: import_zod.z.coerce.number(),
+      yieldOverTvl: import_zod.z.coerce.number()
+    }),
+    "30d": import_zod.z.object({
+      volume: import_zod.z.coerce.number(),
+      fees: import_zod.z.coerce.number(),
+      rewards: import_zod.z.coerce.number(),
+      yieldOverTvl: import_zod.z.coerce.number()
+    })
+  })
+});
+var Tick = import_zod.z.object({
+  index: import_zod.z.number(),
+  liquidity: import_zod.z.coerce.bigint()
+});
+var PoolTicks = import_zod.z.object({
+  tickSpacing: import_zod.z.number(),
+  ticks: Tick.array()
+});
+var LendingPosition = import_zod.z.object({
+  address: import_zod.z.string(),
+  authority: import_zod.z.string(),
+  mint: import_zod.z.string(),
+  vault: import_zod.z.string(),
+  shares: import_zod.z.coerce.bigint(),
+  funds: amountWithUsd,
+  earned: amountWithUsd
+});
+var TunaPosition = import_zod.z.object({
+  address: import_zod.z.string(),
+  authority: import_zod.z.string(),
+  version: import_zod.z.number(),
+  state: TunaPositionStateSchema,
+  positionMint: import_zod.z.string(),
+  liquidity: import_zod.z.coerce.bigint(),
+  tickLowerIndex: import_zod.z.number(),
+  tickUpperIndex: import_zod.z.number(),
+  tickEntryIndex: import_zod.z.number(),
+  tickStopLossIndex: import_zod.z.number(),
+  tickTakeProfitIndex: import_zod.z.number(),
+  swapToTokenOnLimitOrder: import_zod.z.number(),
+  flags: import_zod.z.number(),
+  pool: import_zod.z.string(),
+  poolSqrtPrice: import_zod.z.coerce.bigint(),
+  depositedCollateralA: amountWithoutUsd,
+  depositedCollateralB: amountWithoutUsd,
+  depositedCollateralUsd: import_zod.z.object({
+    amount: import_zod.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: import_zod.z.coerce.date(),
+  updatedAtSlot: import_zod.z.coerce.bigint()
+});
+var PoolSwap = import_zod.z.object({
+  id: import_zod.z.string(),
+  amountIn: import_zod.z.coerce.bigint(),
+  amountOut: import_zod.z.coerce.bigint(),
+  aToB: import_zod.z.boolean(),
+  pool: import_zod.z.string(),
+  time: import_zod.z.coerce.date()
+});
+var OrderBookEntry = import_zod.z.object({
+  concentratedAmount: import_zod.z.coerce.bigint(),
+  concentratedAmountQuote: import_zod.z.coerce.bigint(),
+  concentratedTotal: import_zod.z.coerce.bigint(),
+  concentratedTotalQuote: import_zod.z.coerce.bigint(),
+  limitAmount: import_zod.z.coerce.bigint(),
+  limitAmountQuote: import_zod.z.coerce.bigint(),
+  limitTotal: import_zod.z.coerce.bigint(),
+  limitTotalQuote: import_zod.z.coerce.bigint(),
+  price: import_zod.z.number(),
+  askSide: import_zod.z.boolean()
+});
+var PoolPriceUpdate = import_zod.z.object({
+  pool: import_zod.z.string(),
+  price: import_zod.z.number(),
+  sqrtPrice: import_zod.z.coerce.bigint(),
+  time: import_zod.z.coerce.date()
+});
+var OrderBook = import_zod.z.object({
+  entries: OrderBookEntry.array(),
+  poolPrice: import_zod.z.number()
+});
+var LimitOrder = import_zod.z.object({
+  address: import_zod.z.string(),
+  mint: import_zod.z.string(),
+  pool: import_zod.z.string(),
+  state: LimitOrderStateSchema,
+  aToB: import_zod.z.boolean(),
+  tickIndex: import_zod.z.number(),
+  fillRatio: import_zod.z.number(),
+  openTxSignature: import_zod.z.string(),
+  closeTxSignature: import_zod.z.string().nullable(),
+  amount: amountWithUsd,
+  openedAt: import_zod.z.coerce.date(),
+  closedAt: import_zod.z.coerce.date().nullable()
+});
+var PoolPriceCandle = import_zod.z.object({
+  time: import_zod.z.number(),
+  open: import_zod.z.number(),
+  close: import_zod.z.number(),
+  high: import_zod.z.number(),
+  low: import_zod.z.number()
+});
+var createNotificationSchema = (dataSchema, metaSchema) => import_zod.z.object({
+  entity: NotificationEntitySchema,
+  action: NotificationActionSchema,
+  data: dataSchema,
+  id: import_zod.z.string(),
+  authority: import_zod.z.nullable(import_zod.z.string()),
+  ...metaSchema ? { meta: metaSchema } : { meta: import_zod.z.undefined().nullable() }
+});
+var OrderBookNotificationMeta = import_zod.z.object({
+  pool: import_zod.z.string(),
+  priceStep: import_zod.z.number(),
+  inverted: import_zod.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 = (0, import_camelcase_keys.default)(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));
+      }
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NotificationAction,
+  NotificationEntity,
+  PoolProvider,
+  ProviderFilter,
+  TunaApiClient,
+  TunaPositionState,
+  schemas
+});