@parifi/sdk/dist/subgraph/orders/index.mjs

Parifi SDK with common utility functions

// src/subgraph/orders/index.ts
import { request } from "graphql-request";

// src/subgraph/orders/subgraphQueries.ts
import { gql } from "graphql-request";
var fetchOrdersByUserQuery = (userAddress, count = 50, skip = 0) => gql`{
    snxAccounts(
      first: ${count}
      skip: ${skip}
      where: { owner: "${userAddress}", type: PERP }) {
      id
      accountId
      owner {
        id
      }
      collateralDeposits {
        id
        collateralName
        collateralSymbol
        collateralDecimals
        collateralAddress
        currentDepositedAmount
        totalAmountDeposited
        totalAmountWithdrawn
        totalAmountLiquidated
      }
      orders {
        id
        market {
          id
          marketName
          marketSymbol
          feedId
        }
        expirationTime
        deltaSize
        executionPrice
        isLimitOrder
        status
        createdTimestamp
        txHash
        partnerAddress
        collectedFees
        settledTxHash
        settledTimestamp
        deltaSizeUsd
        acceptablePrice
        snapshotCollateralValueUsd
        settledBy {
          id
        }
      }
    }
  }
`;
var fetchSettledOrdersCountBasedOnTimeStampByUserQuery = (userAddress, count = 50, skip = 0, startTimeStamp, endTimeStamp) => gql`{
    snxAccounts(
      first: ${count}
      skip: ${skip}
      where: { owner: "${userAddress}", type: PERP }) {
      id
      accountId
      owner {
        id
      }
       orders(
      where: {status: SETTLED, createdTimestamp_gt: ${startTimeStamp}, createdTimestamp_lt: ${endTimeStamp}}
    ) {
        id
      }
    }
  }
`;
var fetchOrdersByIdQuery = (orderId) => gql`
  {
    order(id: "${orderId}") {
    id
    market {
      id
      marketName
      marketSymbol
      feedId
    }
    expirationTime
    deltaSize
    executionPrice
    isLimitOrder
    status
    createdTimestamp
    txHash
    partnerAddress
    collectedFees
    settledTxHash
    settledTimestamp
    deltaSizeUsd
    acceptablePrice
    snapshotCollateralValueUsd
    settledBy {
      id
    }
    snxAccount {
      id
      accountId
    }
  }
}
`;

// src/common/subgraphMapper.ts
var mapResponseToWallet = (response) => {
  if (!response) return void 0;
  try {
    return {
      id: response?.id
      // snxAccounts: mapSnxAccountsArray(response.snxAccounts)
    };
  } catch (error) {
    console.log("Error while mapping data", error);
    return void 0;
  }
};
var mapResponseToSnxAccount = (response) => {
  if (!response) return void 0;
  try {
    return {
      id: response?.id,
      type: response?.type,
      accountId: response?.accountId,
      owner: response?.owner ?? mapResponseToWallet(response?.owner),
      totalOrdersCount: response?.totalOrdersCount,
      totalPositionsCount: response?.totalPositionsCount,
      openPositionCount: response?.openPositionCount,
      countProfitablePositions: response?.countProfitablePositions,
      countLossPositions: response?.countLossPositions,
      countLiquidatedPositions: response?.countLiquidatedPositions,
      realizedPnlFromPositions: response?.realizedPnlFromPositions,
      totalFeesPaid: response?.totalFeesPaid,
      finalPnlAfterFees: response?.finalPnlAfterFees,
      totalVolumeInUsd: response?.totalVolumeInUsd,
      totalAccruedBorrowingFeesInUsd: response?.totalAccruedBorrowingFeesInUsd,
      integratorFeesGenerated: response?.integratorFeesGenerated,
      orders: response?.orders ? mapResponseToOrderArray(response?.orders) : [],
      positions: response?.positions ? mapResponseToPositionArray(response?.positions) : [],
      collateralDeposits: response?.collateralDeposits ? mapResponseToCollateralDepositArray(response?.collateralDeposits) : []
    };
  } catch (error) {
    console.log("Error while mapping data", error);
    return void 0;
  }
};
var mapResponseToSnxAccountArray = (response) => {
  if (!response) return void 0;
  try {
    return response.map((snxAccount) => {
      return mapResponseToSnxAccount(snxAccount);
    });
  } catch (error) {
    console.log("Error while mapping data", error);
    return void 0;
  }
};
var mapResponseToMarket = (response) => {
  if (!response) return void 0;
  if (response?.marketName === "" || response?.marketSymbol === "") return void 0;
  try {
    return {
      id: response?.id ?? "",
      marketName: response?.marketName ?? "",
      marketSymbol: response?.marketSymbol ?? "",
      feedId: response?.feedId ?? "",
      skew: response?.skew ?? "0",
      size: response?.size ?? "0",
      maxOpenInterest: response?.maxOpenInterest ?? "0",
      interestRate: response?.interestRate ?? "0",
      currentFundingRate: response?.currentFundingRate ?? "0",
      currentFundingVelocity: response?.currentFundingVelocity ?? "0",
      indexPrice: response?.indexPrice ?? "0",
      skewScale: response?.skewScale ?? "0",
      maxFundingVelocity: response?.maxFundingVelocity ?? "0",
      makerFee: response?.makerFee ?? "0",
      takerFee: response?.takerFee ?? "0",
      maxMarketValue: response?.maxMarketValue ?? "0",
      maxMarketSize: response?.maxMarketSize ?? "0",
      marketPrice: response?.marketPrice ?? "0",
      initialMarginRatioD18: response?.initialMarginRatioD18 ?? "0",
      maintenanceMarginRatioD18: response?.maintenanceMarginRatioD18 ?? "0",
      minimumInitialMarginRatioD18: response?.minimumInitialMarginRatioD18 ?? "0",
      flagRewardRatioD18: response?.flagRewardRatioD18 ?? "0",
      minimumPositionMargin: response?.minimumPositionMargin ?? "0",
      openInterestUsd: response?.openInterestUsd ?? "0"
    };
  } catch (error) {
    console.log("Error while mapping data", error);
    return void 0;
  }
};
var mapResponseToOrder = (response) => {
  if (!response) return void 0;
  try {
    return {
      id: response?.id,
      market: response?.market ?? mapResponseToMarket(response?.market),
      snxAccountId: response?.snxAccount?.id,
      isLimitOrder: response?.isLimitOrder,
      acceptablePrice: response?.acceptablePrice,
      commitmentTime: response?.commitmentTime,
      expectedPriceTime: response?.expectedPriceTime,
      settlementTime: response?.settlementTime,
      expirationTime: response?.expirationTime,
      trackingCode: response?.trackingCode,
      deltaSize: response?.deltaSize,
      deltaSizeUsd: response?.deltaSizeUsd,
      executionPrice: response?.executionPrice,
      collectedFees: response?.collectedFees,
      settlementReward: response?.settlementReward,
      referralFees: response?.referralFees,
      partnerAddress: response?.partnerAddress,
      txHash: response?.txHash,
      createdTimestamp: response?.createdTimestamp,
      status: response?.status,
      settledTxHash: response?.settledTxHash,
      cancellationTxHash: response?.cancellationTxHash,
      settledTimestamp: response?.settledTimestamp,
      settledTimestampISO: response?.settledTimestampISO,
      settledBy: response?.settledBy ?? mapResponseToWallet(response?.settledBy),
      snapshotCollateralValueUsd: response?.snapshotCollateralValueUsd
    };
  } catch (error) {
    console.log("Error while mapping data", error);
    return void 0;
  }
};
var mapResponseToOrderArray = (response) => {
  if (!response) return void 0;
  try {
    return response.map((order) => {
      return mapResponseToOrder(order);
    });
  } catch (error) {
    console.log("Error while mapping data", error);
    return void 0;
  }
};
function mapResponseToCollateralDeposit(response) {
  if (!response) return void 0;
  try {
    return {
      id: response?.id,
      snxAccountId: response?.snxAccountId,
      collateralId: response?.collateralId,
      collateralName: response?.collateralName,
      collateralSymbol: response?.collateralSymbol,
      collateralDecimals: response?.collateralDecimals,
      collateralAddress: response?.collateralAddress,
      currentDepositedAmount: response?.currentDepositedAmount,
      totalAmountDeposited: response?.totalAmountDeposited,
      totalAmountWithdrawn: response?.totalAmountWithdrawn,
      totalAmountLiquidated: response?.totalAmountLiquidated
    };
  } catch (error) {
    console.log("Error while mapping data", error);
    return void 0;
  }
}
var mapResponseToCollateralDepositArray = (response) => {
  if (!response) return void 0;
  try {
    return response.map((deposit) => {
      return mapResponseToCollateralDeposit(deposit);
    });
  } catch (error) {
    console.log("Error while mapping data", error);
    return void 0;
  }
};
var mapResponseToPosition = (response) => {
  if (!response) return void 0;
  try {
    return {
      id: response?.id,
      market: response?.market ?? mapResponseToMarket(response?.market),
      snxAccountId: response?.snxAccountId,
      isLong: response?.isLong,
      positionSize: response?.positionSize,
      avgPrice: response?.avgPrice,
      avgPriceDec: response?.avgPriceDec,
      status: response?.status,
      txHash: response?.txHash,
      liquidationTxHash: response?.liquidationTxHash,
      closingPrice: response?.closingPrice,
      realizedPositionPnl: response?.realizedPositionPnl,
      totalFeesPaid: response?.totalFeesPaid,
      realizedPnlAfterFees: response?.realizedPnlAfterFees,
      createdTimestamp: response?.createdTimestamp,
      lastRefresh: response?.lastRefresh,
      lastRefreshISO: response?.lastRefreshISO,
      accruedBorrowingFees: response?.accruedBorrowingFees,
      canBeLiquidated: response?.canBeLiquidated,
      snapshotCollateralValueUsd: response?.snapshotCollateralValueUsd
    };
  } catch (error) {
    console.log("Error while mapping data", error);
    return void 0;
  }
};
var mapResponseToPositionArray = (response) => {
  if (!response) return void 0;
  try {
    return response.map((position) => {
      return mapResponseToPosition(position);
    });
  } catch (error) {
    console.log("Error while mapping data", error);
    return void 0;
  }
};

// src/error/not-found.error.ts
var NotFoundError = class extends Error {
  constructor(message) {
    super(message);
    this.name = this.constructor.name;
  }
};

// src/subgraph/orders/index.ts
var getAllOrdersByUserAddress = async (subgraphEndpoint, userAddress, count = 10, skip = 0) => {
  try {
    const subgraphResponse = await request(subgraphEndpoint, fetchOrdersByUserQuery(userAddress, count, skip));
    const snxAccounts = mapResponseToSnxAccountArray(subgraphResponse?.snxAccounts);
    return snxAccounts ?? [];
  } catch (error) {
    console.error("Error fetching orders:", error);
    return [];
  }
};
var getOrderById = async (subgraphEndpoint, orderId) => {
  try {
    let subgraphResponse = await request(subgraphEndpoint, fetchOrdersByIdQuery(orderId));
    console.log("subgraph response:", subgraphResponse);
    const order = mapResponseToOrder(subgraphResponse?.order);
    if (order) return order;
    throw new NotFoundError("Order id not found");
  } catch (error) {
    console.error("Error fetching orders:", error);
    throw new NotFoundError("Order id not found");
  }
};
var getSettledOrdersCountBasedOnTimeStampByUserAddress = async (subgraphEndpoint, userAddress, count = 50, skip = 0, startTimeStamp, endTimeStamp) => {
  try {
    const response = await request(
      subgraphEndpoint,
      fetchSettledOrdersCountBasedOnTimeStampByUserQuery(userAddress, count, skip, startTimeStamp, endTimeStamp)
    );
    const snxAccounts = mapResponseToSnxAccountArray(response?.snxAccounts) ?? [];
    if (!snxAccounts.length) return 0;
    const orderCount = snxAccounts.reduce((total, account) => total + (account.orders?.length || 0), 0);
    return orderCount;
  } catch (error) {
    console.error("Error fetching orders:", error);
    return 0;
  }
};
export {
  getAllOrdersByUserAddress,
  getOrderById,
  getSettledOrdersCountBasedOnTimeStampByUserAddress
};
//# sourceMappingURL=index.mjs.map