@parifi/sdk/dist/common/subgraphMapper.js

Parifi SDK with common utility functions

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/common/subgraphMapper.ts
var subgraphMapper_exports = {};
__export(subgraphMapper_exports, {
  mapResponseToCollateralDepositArray: () => mapResponseToCollateralDepositArray,
  mapResponseToMarket: () => mapResponseToMarket,
  mapResponseToMarketArray: () => mapResponseToMarketArray,
  mapResponseToOrder: () => mapResponseToOrder,
  mapResponseToOrderArray: () => mapResponseToOrderArray,
  mapResponseToPosition: () => mapResponseToPosition,
  mapResponseToPositionArray: () => mapResponseToPositionArray,
  mapResponseToPriceFeedSnapshot: () => mapResponseToPriceFeedSnapshot,
  mapResponseToPythData: () => mapResponseToPythData,
  mapResponseToSnxAccount: () => mapResponseToSnxAccount,
  mapResponseToSnxAccountArray: () => mapResponseToSnxAccountArray,
  mapResponseToToken: () => mapResponseToToken,
  mapResponseToWallet: () => mapResponseToWallet,
  mapResponseToWalletArray: () => mapResponseToWalletArray
});
module.exports = __toCommonJS(subgraphMapper_exports);
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 mapResponseToWalletArray = (response) => {
  if (!response) return void 0;
  try {
    return response.map((account) => {
      return mapResponseToWallet(account);
    });
  } 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 mapResponseToMarketArray = (response) => {
  if (!response) return void 0;
  try {
    return response.map((market) => {
      return mapResponseToMarket(market);
    });
  } 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;
  }
};
var mapResponseToToken = (response) => {
  if (!response) return void 0;
  try {
    return {
      id: response?.id,
      name: response?.name,
      symbol: response?.symbol,
      decimals: response?.decimals,
      lastPriceUSD: response?.lastPriceUSD,
      lastPriceTimestamp: response?.lastPriceTimestamp
    };
  } catch (error) {
    console.log("Error while mapping data", error);
    return void 0;
  }
};
var mapResponseToPriceFeedSnapshot = (response) => {
  if (!response) return void 0;
  try {
    return {
      id: response?.id,
      priceId: response?.priceId,
      publishTime: response?.publishTime,
      price: response?.price,
      confidence: response?.confidence
    };
  } catch (error) {
    console.log("Error while mapping data", error);
    return void 0;
  }
};
var mapResponseToPythData = (response) => {
  if (!response) return void 0;
  try {
    return {
      id: response?.id,
      marketId: response?.marketId,
      tokenAddress: response?.tokenAddress,
      price: response?.price,
      lastUpdatedTimestamp: response?.lastUpdatedTimestamp
    };
  } catch (error) {
    console.log("Error while mapping data", error);
    return void 0;
  }
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  mapResponseToCollateralDepositArray,
  mapResponseToMarket,
  mapResponseToMarketArray,
  mapResponseToOrder,
  mapResponseToOrderArray,
  mapResponseToPosition,
  mapResponseToPositionArray,
  mapResponseToPriceFeedSnapshot,
  mapResponseToPythData,
  mapResponseToSnxAccount,
  mapResponseToSnxAccountArray,
  mapResponseToToken,
  mapResponseToWallet,
  mapResponseToWalletArray
});
//# sourceMappingURL=subgraphMapper.js.map