@strobelabs/perpcity-sdk 0.1.7 → 0.2.1

package/dist/index.mjs

@@ -1,49 +1,7 @@
 // src/context.ts
 import { GraphQLClient } from "graphql-request";
-
-// src/deployments.ts
-var DEPLOYMENTS = {
-  // Base Sepolia
-  [84532]: {
-    perpManager: "0x59F1766b77fd67af6c80217C2025A0D536998000",
-    usdc: "0xC1a5D4E99BB224713dd179eA9CA2Fa6600706210",
-    goldskyPublic: "https://api.goldsky.com/api/public/project_cmbawn40q70fj01ws4jmsfj7f/subgraphs/perp-city/36ac28e6-20250925_150813/gn",
-    goldskyPrivate: "https://api.goldsky.com/api/private/project_cmbawn40q70fj01ws4jmsfj7f/subgraphs/perp-city/36ac28e6-20250925_150813/gn"
-  }
-};
-
-// src/context.ts
-import { publicActions } from "viem";
-var PerpCityContext = class {
-  constructor(config) {
-    this.walletClient = config.walletClient.extend(publicActions);
-    const chainId = this.validateChainId();
-    const deployments = DEPLOYMENTS[chainId];
-    const headers = {};
-    let goldskyEndpoint;
-    if (config.goldskyBearerToken) {
-      headers.authorization = `Bearer ${config.goldskyBearerToken}`;
-      goldskyEndpoint = deployments.goldskyPrivate;
-    } else {
-      goldskyEndpoint = deployments.goldskyPublic;
-    }
-    this.goldskyClient = new GraphQLClient(goldskyEndpoint, {
-      headers
-    });
-  }
-  validateChainId() {
-    const chainId = this.walletClient.chain?.id;
-    if (!chainId) throw new Error(`Chain ID is not set.`);
-    if (!DEPLOYMENTS[chainId]) throw new Error(`Unsupported chainId: ${chainId}.`);
-    return chainId;
-  }
-  deployments() {
-    return DEPLOYMENTS[this.validateChainId()];
-  }
-};
-
-// src/entities/openPosition.ts
-import { publicActions as publicActions2 } from "viem";
+import { publicActions, formatUnits } from "viem";
+import { parse } from "graphql";
 
 // src/utils/constants.ts
 var NUMBER_1E6 = 1e6;
@@ -1436,451 +1394,524 @@ async function estimateLiquidity(context, tickLower, tickUpper, usdScaled) {
   });
 }
 
-// src/entities/openPosition.ts
-var OpenPosition = class _OpenPosition {
-  constructor(context, perpId, positionId) {
-    this.context = context;
-    this.perpId = perpId;
-    this.positionId = positionId;
+// src/utils/errors.ts
+import { BaseError, ContractFunctionRevertedError } from "viem";
+var PerpCityError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "PerpCityError";
   }
-  async closePosition(params) {
-    const contractParams = {
-      posId: this.positionId,
-      minAmt0Out: scale6Decimals(params.minAmt0Out),
-      minAmt1Out: scale6Decimals(params.minAmt1Out),
-      maxAmt1In: scale6Decimals(params.maxAmt1In)
-    };
-    const { result, request } = await this.context.walletClient.extend(publicActions2).simulateContract({
-      address: this.context.deployments().perpManager,
-      abi: PERP_MANAGER_ABI,
-      functionName: "closePosition",
-      args: [this.perpId, contractParams],
-      account: this.context.walletClient.account
-    });
-    await this.context.walletClient.writeContract(request);
-    return result === null ? null : new _OpenPosition(this.context, this.perpId, result);
+};
+var ContractError = class extends PerpCityError {
+  constructor(message, errorName, args, cause) {
+    super(message, cause);
+    this.errorName = errorName;
+    this.args = args;
+    this.name = "ContractError";
   }
-  async liveDetails() {
-    const { result, request } = await this.context.walletClient.simulateContract({
-      address: this.context.deployments().perpManager,
-      abi: PERP_MANAGER_ABI,
-      functionName: "livePositionDetails",
-      args: [this.perpId, this.positionId],
-      account: this.context.walletClient.account
-    });
-    return {
-      pnl: scaleFrom6Decimals(Number(result[0])),
-      fundingPayment: scaleFrom6Decimals(Number(result[1])),
-      effectiveMargin: scaleFrom6Decimals(Number(result[2])),
-      isLiquidatable: result[3]
-    };
+};
+var TransactionRejectedError = class extends PerpCityError {
+  constructor(message = "Transaction rejected by user", cause) {
+    super(message, cause);
+    this.name = "TransactionRejectedError";
   }
 };
-
-// src/entities/perp.ts
-import { nearestUsableTick } from "@uniswap/v3-sdk";
-import { gql } from "graphql-request";
-import { parse } from "graphql";
-var Perp = class {
-  constructor(context, id) {
-    this.context = context;
-    this.id = id;
+var InsufficientFundsError = class extends PerpCityError {
+  constructor(message = "Insufficient funds for transaction", cause) {
+    super(message, cause);
+    this.name = "InsufficientFundsError";
   }
-  // READS
-  async tickSpacing() {
-    return await this.context.walletClient.readContract({
-      address: this.context.deployments().perpManager,
-      abi: PERP_MANAGER_ABI,
-      functionName: "tickSpacing",
-      args: [this.id]
-    });
+};
+var GraphQLError = class extends PerpCityError {
+  constructor(message, cause) {
+    super(message, cause);
+    this.name = "GraphQLError";
   }
-  async mark() {
-    const sqrtPriceX96 = await this.context.walletClient.readContract({
-      address: this.context.deployments().perpManager,
-      abi: PERP_MANAGER_ABI,
-      functionName: "sqrtPriceX96",
-      args: [this.id]
-    });
-    return sqrtPriceX96ToPrice(sqrtPriceX96);
+};
+var RPCError = class extends PerpCityError {
+  constructor(message, cause) {
+    super(message, cause);
+    this.name = "RPCError";
   }
-  async index() {
-    const beacon = await this.beacon();
-    const query = parse(gql`
-      query ($beaconAddr: Bytes!) {
-        beaconSnapshots(
-          first: 1
-          orderBy: timestamp
-          orderDirection: desc
-          where: { beacon: $beaconAddr }
-        ) { indexPrice }
-      }
-    `);
-    const response = await this.context.goldskyClient.request(query, { beaconAddr: beacon });
-    return Number(response.beaconSnapshots[0].indexPrice);
+};
+var ValidationError = class extends PerpCityError {
+  constructor(message, cause) {
+    super(message, cause);
+    this.name = "ValidationError";
   }
-  async beacon() {
-    const query = parse(gql`
-      query ($perpId: Bytes!) {
-        perp(id: $perpId) {
-          beacon { id }
-        }
-      }
-    `);
-    const response = await this.context.goldskyClient.request(query, { perpId: this.id });
-    return response.perp.beacon.id;
+};
+function parseContractError(error) {
+  if (error instanceof PerpCityError) {
+    return error;
   }
-  async lastIndexUpdate() {
-    const beacon = await this.beacon();
-    const query = parse(gql`
-      query ($beaconAddr: Bytes!) {
-        beaconSnapshots(
-          first: 1
-          orderBy: timestamp
-          orderDirection: desc
-          where: { beacon: $beaconAddr }
-        ) { timestamp }
-      }
-    `);
-    const response = await this.context.goldskyClient.request(query, { beaconAddr: beacon });
-    return Number(response.beaconSnapshots[0].timestamp);
+  if (error instanceof BaseError) {
+    const revertError = error.walk((err) => err instanceof ContractFunctionRevertedError);
+    if (revertError instanceof ContractFunctionRevertedError) {
+      const errorName = revertError.data?.errorName ?? "Unknown";
+      const args = revertError.data?.args ?? [];
+      const message = formatContractError(errorName, args);
+      return new ContractError(message, errorName, args, error);
+    }
+    if (error.message?.includes("User rejected") || error.code === 4001) {
+      return new TransactionRejectedError(error.message, error);
+    }
+    if (error.message?.includes("insufficient funds")) {
+      return new InsufficientFundsError(error.message, error);
+    }
+    return new PerpCityError(error.shortMessage || error.message, error);
   }
-  async openInterest() {
-    const query = parse(gql`
-      query ($perpId: Bytes!) {
-        perpSnapshots(
-          first: 1
-          orderBy: timestamp
-          orderDirection: desc
-          where: { perp: $perpId }
-        ) {
-          takerLongNotional
-          takerShortNotional
-        }
-      }
-    `);
-    const response = await this.context.goldskyClient.request(query, { perpId: this.id });
-    return {
-      takerLongNotional: Number(response.perpSnapshots[0].takerLongNotional),
-      takerShortNotional: Number(response.perpSnapshots[0].takerShortNotional)
-    };
+  if (error instanceof Error) {
+    return new PerpCityError(error.message, error);
   }
-  async markTimeSeries() {
-    const query = parse(gql`
-      query ($perpId: Bytes!) {
-        perpSnapshots(
-          orderBy: timestamp
-          orderDirection: asc
-          where: { perp: $perpId }
-        ) {
-          timestamp
-          markPrice
-        }
-      }
-    `);
-    const response = await this.context.goldskyClient.request(query, { perpId: this.id });
-    return response.perpSnapshots.map((snapshot) => ({
-      timestamp: Number(snapshot.timestamp),
-      value: Number(snapshot.markPrice)
-    }));
-  }
-  async indexTimeSeries() {
-    const beacon = await this.beacon();
-    const query = parse(gql`
-      query ($beaconAddr: Bytes!) {
-        beaconSnapshots(
-          orderBy: timestamp
-          orderDirection: asc
-          where: { beacon: $beaconAddr }
-        ) {
-          timestamp
-          indexPrice
-        }
-      }
-    `);
-    const response = await this.context.goldskyClient.request(query, { beaconAddr: beacon });
-    return response.beaconSnapshots.map((snapshot) => ({
-      timestamp: Number(snapshot.timestamp),
-      value: Number(snapshot.indexPrice)
-    }));
+  return new PerpCityError(String(error));
+}
+function formatContractError(errorName, args) {
+  switch (errorName) {
+    case "InvalidBeaconAddress":
+      return `Invalid beacon address: ${args[0]}`;
+    case "InvalidTradingFeeSplits":
+      return `Invalid trading fee splits. Insurance split: ${args[0]}, Creator split: ${args[1]}`;
+    case "InvalidMaxOpeningLev":
+      return `Invalid maximum opening leverage: ${args[0]}`;
+    case "InvalidLiquidationLev":
+      return `Invalid liquidation leverage: ${args[0]}. Must be less than max opening leverage: ${args[1]}`;
+    case "InvalidLiquidationFee":
+      return `Invalid liquidation fee: ${args[0]}`;
+    case "InvalidLiquidatorFeeSplit":
+      return `Invalid liquidator fee split: ${args[0]}`;
+    case "InvalidClose":
+      return `Cannot close position. Caller: ${args[0]}, Holder: ${args[1]}, Is Liquidated: ${args[2]}`;
+    case "InvalidCaller":
+      return `Invalid caller. Expected: ${args[1]}, Got: ${args[0]}`;
+    case "InvalidLiquidity":
+      return `Invalid liquidity amount: ${args[0]}`;
+    case "InvalidMargin":
+      return `Invalid margin amount: ${args[0]}`;
+    case "InvalidLevX96":
+      return `Invalid leverage: ${args[0]}. Maximum allowed: ${args[1]}`;
+    case "MakerPositionLocked":
+      return `Maker position is locked until ${new Date(Number(args[1]) * 1e3).toISOString()}. Current time: ${new Date(Number(args[0]) * 1e3).toISOString()}`;
+    case "MaximumAmountExceeded":
+      return `Maximum amount exceeded. Maximum: ${args[0]}, Requested: ${args[1]}`;
+    case "MinimumAmountInsufficient":
+      return `Minimum amount not met. Required: ${args[0]}, Received: ${args[1]}`;
+    case "PriceImpactTooHigh":
+      return `Price impact too high. Current price: ${args[0]}, Min acceptable: ${args[1]}, Max acceptable: ${args[2]}`;
+    case "SwapReverted":
+      return "Swap failed. This may be due to insufficient liquidity or slippage tolerance.";
+    case "ZeroSizePosition":
+      return `Cannot create zero-size position. Perp delta: ${args[0]}, USD delta: ${args[1]}`;
+    case "InvalidFundingInterval":
+      return `Invalid funding interval: ${args[0]}`;
+    case "InvalidPriceImpactBand":
+      return `Invalid price impact band: ${args[0]}`;
+    case "InvalidMarketDeathThreshold":
+      return `Invalid market death threshold: ${args[0]}`;
+    case "InvalidTickRange":
+      return `Invalid tick range. Lower: ${args[0]}, Upper: ${args[1]}`;
+    case "MarketNotKillable":
+      return `Market health (${args[0]}) is above death threshold (${args[1]}). Market cannot be killed yet.`;
+    case "InvalidStartingSqrtPriceX96":
+      return `Invalid starting sqrt price: ${args[0]}`;
+    default:
+      return `Contract error: ${errorName}${args.length > 0 ? ` (${args.join(", ")})` : ""}`;
   }
-  async fundingRate() {
-    const query = parse(gql`
-      query ($perpId: Bytes!) {
-        perpSnapshots(
-          first: 1
-          orderBy: timestamp
-          orderDirection: desc
-          where: { perp: $perpId }
-        ) {
-          fundingRate
-        }
-      }
-    `);
-    const response = await this.context.goldskyClient.request(query, { perpId: this.id });
-    return Number(response.perpSnapshots[0].fundingRate);
+}
+async function withErrorHandling(fn, context) {
+  try {
+    return await fn();
+  } catch (error) {
+    const parsedError = parseContractError(error);
+    parsedError.message = `${context}: ${parsedError.message}`;
+    throw parsedError;
   }
-  async bounds() {
-    const result = await this.context.walletClient.readContract({
-      address: this.context.deployments().perpManager,
-      abi: PERP_MANAGER_ABI,
-      functionName: "tradingBounds",
-      args: [this.id]
+}
+
+// src/context.ts
+import { erc20Abi as erc20Abi2 } from "viem";
+var PerpCityContext = class {
+  constructor(config) {
+    this.walletClient = config.walletClient.extend(publicActions);
+    this._deployments = config.deployments;
+    const headers = {};
+    if (config.goldskyBearerToken) {
+      headers.authorization = `Bearer ${config.goldskyBearerToken}`;
+    }
+    this.goldskyClient = new GraphQLClient(config.goldskyEndpoint, {
+      headers
     });
-    return {
-      minMargin: Number(result[0]),
-      minTakerLeverage: marginRatioToLeverage(result[5]),
-      maxTakerLeverage: marginRatioToLeverage(result[4])
-    };
-  }
-  // TODO
-  async maxTakerNotional(isLong) {
-    return 0;
   }
-  async simulateTaker(params) {
-    const contractParams = {
-      isLong: params.isLong,
-      margin: scale6Decimals(params.margin),
-      levX96: scaleToX96(params.leverage),
-      unspecifiedAmountLimit: scale6Decimals(params.unspecifiedAmountLimit)
-    };
-    const { result, request } = await this.context.walletClient.simulateContract({
-      address: this.context.deployments().perpManager,
-      abi: PERP_MANAGER_ABI,
-      functionName: "quoteTakerPosition",
-      args: [this.id, contractParams],
-      account: this.context.walletClient.account
-    });
-    return {
-      success: result[0],
-      size: scaleFrom6Decimals(Math.abs(Number(result[1]))),
-      notional: scaleFrom6Decimals(Math.abs(Number(result[2]))),
-      creatorFeeAmt: scaleFrom6Decimals(Number(result[3])),
-      insuranceFeeAmt: scaleFrom6Decimals(Number(result[4])),
-      lpFeeAmt: scaleFrom6Decimals(Number(result[5]))
-    };
+  deployments() {
+    return this._deployments;
   }
-  async allMakerPositions() {
-    const query = parse(gql`
-      query ($perpId: Bytes!) {
-        openPositions(
-          where: { perp: $perpId, isMaker: true }
-        ) {
-          perp { id }
-          inContractPosId
+  // Optimized batch data fetching methods
+  async fetchPerpData(perpId) {
+    return withErrorHandling(async () => {
+      const perpQuery = parse(`
+        query ($perpId: Bytes!) {
+          perp(id: $perpId) {
+            beacon { id }
+          }
+          perpSnapshots(
+            orderBy: timestamp
+            orderDirection: asc
+            where: { perp: $perpId }
+          ) {
+            timestamp
+            markPrice
+            takerLongNotional
+            takerShortNotional
+            fundingRate
+          }
         }
-      }
-    `);
-    const response = await this.context.goldskyClient.request(query, { perpId: this.id });
-    return response.openPositions.map((position) => new OpenPosition(this.context, position.perp.id, position.inContractPosId));
-  }
-  async allTakerPositions() {
-    const query = parse(gql`
-      query ($perpId: Bytes!) {
-        openPositions(
-          where: { perp: $perpId, isMaker: false }
-        ) {
-          perp { id }
-          inContractPosId
+      `);
+      const beaconQuery = parse(`
+        query ($beaconAddr: Bytes!) {
+          beaconSnapshots(
+            orderBy: timestamp
+            orderDirection: asc
+            where: { beacon: $beaconAddr }
+          ) {
+            timestamp
+            indexPrice
+          }
         }
-      }
-    `);
-    const response = await this.context.goldskyClient.request(query, { perpId: this.id });
-    return response.openPositions.map((position) => new OpenPosition(this.context, position.perp.id, position.inContractPosId));
+      `);
+      let perpResponse;
+      try {
+        perpResponse = await this.goldskyClient.request(perpQuery, { perpId });
+      } catch (error) {
+        throw new GraphQLError(`Failed to fetch perp data for ${perpId}: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : void 0);
+      }
+      if (!perpResponse.perp || !perpResponse.perp.beacon) {
+        throw new GraphQLError(`Perp ${perpId} not found or has no beacon`);
+      }
+      let beaconResponse;
+      let contractData;
+      try {
+        [beaconResponse, contractData] = await Promise.all([
+          this.goldskyClient.request(beaconQuery, { beaconAddr: perpResponse.perp.beacon.id }),
+          this.fetchPerpContractData(perpId)
+        ]);
+      } catch (error) {
+        if (error instanceof GraphQLError || error instanceof RPCError) {
+          throw error;
+        }
+        throw new GraphQLError(`Failed to fetch beacon or contract data: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : void 0);
+      }
+      if (perpResponse.perpSnapshots.length === 0) {
+        throw new GraphQLError(`No perpSnapshots found for perp ${perpId}. This perp may be newly created with no trading activity yet.`);
+      }
+      if (beaconResponse.beaconSnapshots.length === 0) {
+        throw new GraphQLError(`No beaconSnapshots found for perp ${perpId} beacon ${perpResponse.perp.beacon.id}. The beacon may not have any price updates yet.`);
+      }
+      const markTimeSeries = perpResponse.perpSnapshots.map((snapshot) => ({
+        timestamp: Number(snapshot.timestamp),
+        value: Number(snapshot.markPrice)
+      }));
+      const indexTimeSeries = beaconResponse.beaconSnapshots.map((snapshot) => ({
+        timestamp: Number(snapshot.timestamp),
+        value: Number(snapshot.indexPrice)
+      }));
+      const openInterestTimeSeries = perpResponse.perpSnapshots.map((snapshot) => ({
+        timestamp: Number(snapshot.timestamp),
+        value: {
+          takerLongNotional: Number(snapshot.takerLongNotional),
+          takerShortNotional: Number(snapshot.takerShortNotional)
+        }
+      }));
+      const fundingRateTimeSeries = perpResponse.perpSnapshots.map((snapshot) => ({
+        timestamp: Number(snapshot.timestamp),
+        value: Number(snapshot.fundingRate)
+      }));
+      const latestSnapshot = perpResponse.perpSnapshots[perpResponse.perpSnapshots.length - 1];
+      const latestBeaconSnapshot = beaconResponse.beaconSnapshots[beaconResponse.beaconSnapshots.length - 1];
+      const perpData = {
+        id: perpId,
+        tickSpacing: contractData.tickSpacing,
+        mark: sqrtPriceX96ToPrice(contractData.sqrtPriceX96),
+        index: Number(latestBeaconSnapshot.indexPrice),
+        beacon: perpResponse.perp.beacon.id,
+        lastIndexUpdate: Number(latestBeaconSnapshot.timestamp),
+        openInterest: {
+          takerLongNotional: Number(latestSnapshot.takerLongNotional),
+          takerShortNotional: Number(latestSnapshot.takerShortNotional)
+        },
+        markTimeSeries,
+        indexTimeSeries,
+        fundingRate: Number(latestSnapshot.fundingRate),
+        bounds: contractData.bounds,
+        fees: contractData.fees,
+        openInterestTimeSeries,
+        fundingRateTimeSeries,
+        totalOpenMakerPnl: 0,
+        // These will be calculated by functions
+        totalOpenTakerPnl: 0
+        // These will be calculated by functions
+      };
+      return perpData;
+    }, `fetchPerpData for perp ${perpId}`);
   }
-  async totalOpenMakerPnl() {
-    const positions = await this.allMakerPositions();
-    const liveDetails = await Promise.all(positions.map((position) => position.liveDetails()));
-    return liveDetails.reduce((acc, detail) => acc + detail.pnl - detail.fundingPayment, 0);
+  async fetchPerpContractData(perpId) {
+    return withErrorHandling(async () => {
+      const [tickSpacing, sqrtPriceX96, boundsRaw, feesRaw] = await Promise.all([
+        this.walletClient.readContract({
+          address: this.deployments().perpManager,
+          abi: PERP_MANAGER_ABI,
+          functionName: "tickSpacing",
+          args: [perpId]
+        }),
+        this.walletClient.readContract({
+          address: this.deployments().perpManager,
+          abi: PERP_MANAGER_ABI,
+          functionName: "sqrtPriceX96",
+          args: [perpId]
+        }),
+        this.walletClient.readContract({
+          address: this.deployments().perpManager,
+          abi: PERP_MANAGER_ABI,
+          functionName: "tradingBounds",
+          args: [perpId]
+        }),
+        this.walletClient.readContract({
+          address: this.deployments().perpManager,
+          abi: PERP_MANAGER_ABI,
+          functionName: "fees",
+          args: [perpId]
+        })
+      ]);
+      const bounds = boundsRaw;
+      const fees = feesRaw;
+      return {
+        tickSpacing: Number(tickSpacing),
+        sqrtPriceX96,
+        bounds: {
+          minMargin: Number(formatUnits(bounds[0], 6)),
+          minTakerLeverage: marginRatioToLeverage(Number(formatUnits(bounds[4], 6))),
+          maxTakerLeverage: marginRatioToLeverage(Number(formatUnits(bounds[5], 6)))
+        },
+        fees: {
+          creatorFee: Number(formatUnits(fees[0], 6)),
+          insuranceFee: Number(formatUnits(fees[1], 6)),
+          lpFee: Number(formatUnits(fees[2], 6)),
+          liquidationFee: Number(formatUnits(fees[3], 6))
+        }
+      };
+    }, `fetchPerpContractData for perp ${perpId}`);
   }
-  async totalOpenTakerPnl() {
-    const positions = await this.allTakerPositions();
-    const liveDetails = await Promise.all(positions.map((position) => position.liveDetails()));
-    return liveDetails.reduce((acc, detail) => acc + detail.pnl - detail.fundingPayment, 0);
+  /**
+   * Fetch comprehensive perp data with all related information in a single batched request
+   */
+  async getPerpData(perpId) {
+    return this.fetchPerpData(perpId);
   }
-  async fees() {
-    const result = await this.context.walletClient.readContract({
-      address: this.context.deployments().perpManager,
-      abi: PERP_MANAGER_ABI,
-      functionName: "fees",
-      args: [this.id]
-    });
-    return {
-      creatorFee: scaleFrom6Decimals(result[0]),
-      insuranceFee: scaleFrom6Decimals(result[1]),
-      lpFee: scaleFrom6Decimals(result[2]),
-      liquidationFee: scaleFrom6Decimals(result[3])
-    };
-  }
-  async openInterestTimeSeries() {
-    const query = parse(gql`
-      query ($perpId: Bytes!) {
+  /**
+   * Fetch data for multiple perps efficiently with true batching
+   * This fetches all perps in just 2 Goldsky requests total (not 2N!)
+   */
+  async getMultiplePerpData(perpIds) {
+    if (perpIds.length === 0) {
+      return /* @__PURE__ */ new Map();
+    }
+    if (perpIds.length === 1) {
+      const data = await this.fetchPerpData(perpIds[0]);
+      return /* @__PURE__ */ new Map([[perpIds[0], data]]);
+    }
+    const batchPerpQuery = parse(`
+      query ($perpIds: [Bytes!]!) {
+        perps(where: { id_in: $perpIds }) {
+          id
+          beacon { id }
+        }
         perpSnapshots(
           orderBy: timestamp
           orderDirection: asc
-          where: { perp: $perpId }
+          where: { perp_in: $perpIds }
         ) {
+          perp { id }
           timestamp
+          markPrice
           takerLongNotional
           takerShortNotional
+          fundingRate
         }
       }
     `);
-    const response = await this.context.goldskyClient.request(query, { perpId: this.id });
-    return response.perpSnapshots.map((snapshot) => ({
-      timestamp: Number(snapshot.timestamp),
-      value: {
-        takerLongNotional: Number(snapshot.takerLongNotional),
-        takerShortNotional: Number(snapshot.takerShortNotional)
-      }
-    }));
-  }
-  async fundingRateTimeSeries() {
-    const query = parse(gql`
-      query ($perpId: Bytes!) {
-        perpSnapshots(
+    const perpResponse = await this.goldskyClient.request(batchPerpQuery, { perpIds });
+    const beaconIds = [...new Set(perpResponse.perps.map((p) => p.beacon.id))];
+    const batchBeaconQuery = parse(`
+      query ($beaconIds: [Bytes!]!) {
+        beaconSnapshots(
           orderBy: timestamp
           orderDirection: asc
-          where: { perp: $perpId }
+          where: { beacon_in: $beaconIds }
         ) {
+          beacon { id }
           timestamp
-          fundingRate
+          indexPrice
         }
       }
     `);
-    const response = await this.context.goldskyClient.request(query, { perpId: this.id });
-    return response.perpSnapshots.map((snapshot) => ({
-      timestamp: Number(snapshot.timestamp),
-      value: Number(snapshot.fundingRate)
-    }));
-  }
-  // WRITES
-  async approveAndOpenMakerPosition(params) {
-    await approveUsdc(this.context, scale6Decimals(params.margin));
-    return await this.openMakerPosition(params);
-  }
-  async approveAndOpenTakerPosition(params) {
-    await approveUsdc(this.context, scale6Decimals(params.margin));
-    return await this.openTakerPosition(params);
-  }
-  async openMakerPosition(params) {
-    const deployments = this.context.deployments();
-    const tickSpacing = await this.tickSpacing();
-    const scaledUsd = scale6Decimals(params.margin);
-    const tickLower = nearestUsableTick(priceToTick(params.priceLower, true), tickSpacing);
-    const tickUpper = nearestUsableTick(priceToTick(params.priceUpper, false), tickSpacing);
-    const contractParams = {
-      margin: scaledUsd,
-      liquidity: await estimateLiquidity(this.context, tickLower, tickUpper, scaledUsd),
-      tickLower,
-      tickUpper,
-      maxAmt0In: scale6Decimals(params.maxAmt0In),
-      maxAmt1In: scale6Decimals(params.maxAmt1In)
-    };
-    const { result, request } = await this.context.walletClient.simulateContract({
-      address: deployments.perpManager,
-      abi: PERP_MANAGER_ABI,
-      functionName: "openMakerPosition",
-      args: [this.id, contractParams],
-      account: this.context.walletClient.account
+    const [beaconResponse, contractDataMap] = await Promise.all([
+      this.goldskyClient.request(batchBeaconQuery, { beaconIds }),
+      this.fetchMultiplePerpContractData(perpIds)
+    ]);
+    const snapshotsByPerp = /* @__PURE__ */ new Map();
+    perpResponse.perpSnapshots.forEach((snapshot) => {
+      const perpId = snapshot.perp.id;
+      if (!snapshotsByPerp.has(perpId)) {
+        snapshotsByPerp.set(perpId, []);
+      }
+      snapshotsByPerp.get(perpId).push(snapshot);
     });
-    await this.context.walletClient.writeContract(request);
-    return new OpenPosition(this.context, this.id, result);
-  }
-  async openTakerPosition(params) {
-    const contractParams = {
-      isLong: params.isLong,
-      margin: scale6Decimals(params.margin),
-      levX96: scaleToX96(params.leverage),
-      unspecifiedAmountLimit: scale6Decimals(params.unspecifiedAmountLimit)
-    };
-    const { result, request } = await this.context.walletClient.simulateContract({
-      address: this.context.deployments().perpManager,
-      abi: PERP_MANAGER_ABI,
-      functionName: "openTakerPosition",
-      args: [this.id, contractParams],
-      account: this.context.walletClient.account
+    const snapshotsByBeacon = /* @__PURE__ */ new Map();
+    beaconResponse.beaconSnapshots.forEach((snapshot) => {
+      const beaconId = snapshot.beacon.id;
+      if (!snapshotsByBeacon.has(beaconId)) {
+        snapshotsByBeacon.set(beaconId, []);
+      }
+      snapshotsByBeacon.get(beaconId).push(snapshot);
     });
-    await this.context.walletClient.writeContract(request);
-    return new OpenPosition(this.context, this.id, result);
-  }
-};
-
-// src/entities/perp-manager.ts
-import { gql as gql2 } from "graphql-request";
-import { parse as parse2 } from "graphql";
-var PerpManager = class {
-  constructor(context) {
-    this.context = context;
-  }
-  // READS
-  async getPerps() {
-    const query = parse2(gql2`
-      {
-        perps {
-          id
+    const perpLookup = new Map(
+      perpResponse.perps.map((p) => [
+        p.id,
+        p
+      ])
+    );
+    const resultMap = /* @__PURE__ */ new Map();
+    for (const perpId of perpIds) {
+      const perp = perpLookup.get(perpId);
+      if (!perp) {
+        throw new Error(`Perp ${perpId} not found`);
+      }
+      const beaconId = perp.beacon.id;
+      const snapshots = snapshotsByPerp.get(perpId) || [];
+      const beaconSnapshots = snapshotsByBeacon.get(beaconId) || [];
+      const contractData = contractDataMap.get(perpId);
+      if (!contractData) {
+        throw new Error(`Contract data for perp ${perpId} not found`);
+      }
+      if (snapshots.length === 0) {
+        throw new Error(`No snapshots found for perp ${perpId}`);
+      }
+      if (beaconSnapshots.length === 0) {
+        throw new Error(`No beacon snapshots found for perp ${perpId}`);
+      }
+      const markTimeSeries = snapshots.map((snapshot) => ({
+        timestamp: Number(snapshot.timestamp),
+        value: Number(snapshot.markPrice)
+      }));
+      const indexTimeSeries = beaconSnapshots.map((snapshot) => ({
+        timestamp: Number(snapshot.timestamp),
+        value: Number(snapshot.indexPrice)
+      }));
+      const openInterestTimeSeries = snapshots.map((snapshot) => ({
+        timestamp: Number(snapshot.timestamp),
+        value: {
+          takerLongNotional: Number(snapshot.takerLongNotional),
+          takerShortNotional: Number(snapshot.takerShortNotional)
         }
-      }
-    `);
-    const response = await this.context.goldskyClient.request(query);
-    return response.perps.map(
-      (perpData) => new Perp(this.context, perpData.id)
+      }));
+      const fundingRateTimeSeries = snapshots.map((snapshot) => ({
+        timestamp: Number(snapshot.timestamp),
+        value: Number(snapshot.fundingRate)
+      }));
+      const latestSnapshot = snapshots[snapshots.length - 1];
+      const latestBeaconSnapshot = beaconSnapshots[beaconSnapshots.length - 1];
+      const perpData = {
+        id: perpId,
+        tickSpacing: contractData.tickSpacing,
+        mark: sqrtPriceX96ToPrice(contractData.sqrtPriceX96),
+        index: Number(latestBeaconSnapshot.indexPrice),
+        beacon: beaconId,
+        lastIndexUpdate: Number(latestBeaconSnapshot.timestamp),
+        openInterest: {
+          takerLongNotional: Number(latestSnapshot.takerLongNotional),
+          takerShortNotional: Number(latestSnapshot.takerShortNotional)
+        },
+        markTimeSeries,
+        indexTimeSeries,
+        fundingRate: Number(latestSnapshot.fundingRate),
+        bounds: contractData.bounds,
+        fees: contractData.fees,
+        openInterestTimeSeries,
+        fundingRateTimeSeries,
+        totalOpenMakerPnl: 0,
+        totalOpenTakerPnl: 0
+      };
+      resultMap.set(perpId, perpData);
+    }
+    return resultMap;
+  }
+  async fetchMultiplePerpContractData(perpIds) {
+    const results = await Promise.all(
+      perpIds.map(async (perpId) => ({
+        perpId,
+        data: await this.fetchPerpContractData(perpId)
+      }))
     );
+    return new Map(results.map(({ perpId, data }) => [perpId, data]));
   }
-  // WRITES
-  async createPerp(params) {
-    const sqrtPriceX96 = priceToSqrtPriceX96(params.startingPrice);
-    const contractParams = {
-      startingSqrtPriceX96: sqrtPriceX96,
-      beacon: params.beacon
+  async fetchUserData(userAddress) {
+    const [usdcBalance, openPositionsData, closedPositionsData] = await Promise.all([
+      this.walletClient.readContract({
+        address: this.deployments().usdc,
+        abi: erc20Abi2,
+        functionName: "balanceOf",
+        args: [userAddress]
+      }),
+      this.fetchUserOpenPositions(userAddress),
+      this.fetchUserClosedPositions(userAddress)
+    ]);
+    const realizedPnl = closedPositionsData.reduce((acc, position) => acc + position.pnlAtClose, 0);
+    const unrealizedPnl = openPositionsData.reduce(
+      (acc, position) => acc + position.liveDetails.pnl - position.liveDetails.fundingPayment,
+      0
+    );
+    return {
+      walletAddress: userAddress,
+      usdcBalance: Number(formatUnits(usdcBalance, 6)),
+      openPositions: openPositionsData,
+      closedPositions: closedPositionsData,
+      realizedPnl,
+      unrealizedPnl
     };
-    const { result, request } = await this.context.walletClient.simulateContract({
-      address: this.context.deployments().perpManager,
-      abi: PERP_MANAGER_ABI,
-      functionName: "createPerp",
-      args: [contractParams],
-      account: this.context.walletClient.account
-    });
-    await this.context.walletClient.writeContract(request);
-    return new Perp(this.context, result);
   }
-};
-
-// src/entities/user.ts
-import { erc20Abi as erc20Abi2 } from "viem";
-import { parse as parse3 } from "graphql";
-import { gql as gql3 } from "graphql-request";
-var User = class {
-  constructor(context) {
-    this.context = context;
-    if (!context.walletClient.account) throw new Error("Wallet client account not found");
-    this.walletAddress = context.walletClient.account.address;
-  }
-  async usdcBalance() {
-    const result = await this.context.walletClient.readContract({
-      address: this.context.deployments().usdc,
-      abi: erc20Abi2,
-      functionName: "balanceOf",
-      args: [this.walletAddress]
-    });
-    return scaleFrom6Decimals(Number(result));
-  }
-  async openPositions() {
-    const query = parse3(gql3`
+  async fetchUserOpenPositions(userAddress) {
+    const query = parse(`
       query ($holder: Bytes!) {
         openPositions(
           where: { holder: $holder }
         ) {
           perp { id }
           inContractPosId
+          isLong
+          isMaker
         }
       }
     `);
-    const response = await this.context.goldskyClient.request(query, { holder: this.walletAddress });
-    return response.openPositions.map((position) => new OpenPosition(this.context, position.perp.id, position.inContractPosId));
+    const response = await this.goldskyClient.request(query, { holder: userAddress });
+    const positionsWithDetails = await Promise.all(
+      response.openPositions.map(async (position) => {
+        const positionId = typeof position.inContractPosId === "bigint" ? position.inContractPosId : BigInt(position.inContractPosId);
+        const liveDetails = await this.fetchPositionLiveDetailsFromContract(
+          position.perp.id,
+          positionId
+        );
+        return {
+          perpId: position.perp.id,
+          positionId,
+          isLong: position.isLong,
+          isMaker: position.isMaker,
+          liveDetails
+        };
+      })
+    );
+    return positionsWithDetails;
   }
-  async closedPositions() {
-    const query = parse3(gql3`
+  async fetchUserClosedPositions(userAddress) {
+    const query = parse(`
       query ($holder: Bytes!) {
         closedPositions(
           where: { holder: $holder }
@@ -1892,7 +1923,7 @@ var User = class {
         }
       }
     `);
-    const response = await this.context.goldskyClient.request(query, { holder: this.walletAddress });
+    const response = await this.goldskyClient.request(query, { holder: userAddress });
     return response.closedPositions.map((position) => ({
       perpId: position.perp.id,
       wasMaker: position.wasMaker,
@@ -1900,13 +1931,60 @@ var User = class {
       pnlAtClose: Number(position.pnlAtClose)
     }));
   }
-  async realizedPnl() {
-    return (await this.closedPositions()).reduce((acc, position) => acc + position.pnlAtClose, 0);
+  async fetchPositionLiveDetailsFromContract(perpId, positionId) {
+    return withErrorHandling(async () => {
+      const result = await this.walletClient.readContract({
+        address: this.deployments().perpManager,
+        abi: PERP_MANAGER_ABI,
+        functionName: "livePositionDetails",
+        args: [perpId, positionId]
+      });
+      return {
+        pnl: Number(formatUnits(result[0], 6)),
+        fundingPayment: Number(formatUnits(result[1], 6)),
+        effectiveMargin: Number(formatUnits(result[2], 6)),
+        isLiquidatable: result[3]
+      };
+    }, `fetchPositionLiveDetailsFromContract for position ${positionId}`);
   }
-  async unrealizedPnl() {
-    const openPositions = await this.openPositions();
-    const liveDetails = await Promise.all(openPositions.map((position) => position.liveDetails()));
-    return liveDetails.reduce((acc, detail) => acc + detail.pnl - detail.fundingPayment, 0);
+  /**
+   * Fetch comprehensive user data with all positions in a single batched request
+   */
+  async getUserData(userAddress) {
+    return this.fetchUserData(userAddress);
+  }
+  /**
+   * Fetch open position data with live details
+   */
+  async getOpenPositionData(perpId, positionId) {
+    const query = parse(`
+      query ($perpId: Bytes!, $posId: BigInt!) {
+        openPositions(
+          where: { perp: $perpId, inContractPosId: $posId }
+          first: 1
+        ) {
+          isLong
+          isMaker
+        }
+      }
+    `);
+    const [positionResponse, liveDetails] = await Promise.all([
+      this.goldskyClient.request(query, { perpId, posId: positionId.toString() }),
+      this.fetchPositionLiveDetailsFromContract(perpId, positionId)
+    ]);
+    const position = positionResponse.openPositions[0];
+    if (!position) {
+      throw new Error(
+        `Position not found in GraphQL: perpId=${perpId}, positionId=${positionId}. The position may not exist or may have been closed.`
+      );
+    }
+    return {
+      perpId,
+      positionId,
+      isLong: position.isLong,
+      isMaker: position.isMaker,
+      liveDetails
+    };
   }
 };
 
@@ -2165,27 +2243,511 @@ var BEACON_ABI = [
     "type": "function"
   }
 ];
+
+// src/functions/open-position.ts
+import { publicActions as publicActions2, formatUnits as formatUnits2, decodeEventLog } from "viem";
+var OpenPosition = class _OpenPosition {
+  constructor(context, perpId, positionId, isLong, isMaker) {
+    this.context = context;
+    this.perpId = perpId;
+    this.positionId = positionId;
+    this.isLong = isLong;
+    this.isMaker = isMaker;
+  }
+  async closePosition(params) {
+    return withErrorHandling(async () => {
+      const contractParams = {
+        posId: this.positionId,
+        minAmt0Out: scale6Decimals(params.minAmt0Out),
+        minAmt1Out: scale6Decimals(params.minAmt1Out),
+        maxAmt1In: scale6Decimals(params.maxAmt1In)
+      };
+      const { result, request } = await this.context.walletClient.extend(publicActions2).simulateContract({
+        address: this.context.deployments().perpManager,
+        abi: PERP_MANAGER_ABI,
+        functionName: "closePosition",
+        args: [this.perpId, contractParams],
+        account: this.context.walletClient.account
+      });
+      const txHash = await this.context.walletClient.writeContract(request);
+      const publicClient = this.context.walletClient.extend(publicActions2);
+      const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+      if (receipt.status === "reverted") {
+        throw new Error(`Transaction reverted. Hash: ${txHash}`);
+      }
+      let newPositionId = result && result !== 0n ? result : null;
+      for (const log of receipt.logs) {
+        try {
+          const closedDecoded = decodeEventLog({
+            abi: PERP_MANAGER_ABI,
+            data: log.data,
+            topics: log.topics,
+            eventName: "PositionClosed"
+          });
+          if (closedDecoded.args.perpId === this.perpId && closedDecoded.args.posId === this.positionId) {
+            newPositionId = null;
+            break;
+          }
+        } catch (e) {
+          continue;
+        }
+      }
+      if (!newPositionId) {
+        return null;
+      }
+      return new _OpenPosition(this.context, this.perpId, newPositionId, this.isLong, this.isMaker);
+    }, `closePosition for ${this.isMaker ? "maker" : "taker"} position ${this.positionId}`);
+  }
+  async liveDetails() {
+    return withErrorHandling(async () => {
+      const result = await this.context.walletClient.readContract({
+        address: this.context.deployments().perpManager,
+        abi: PERP_MANAGER_ABI,
+        functionName: "livePositionDetails",
+        args: [this.perpId, this.positionId]
+      });
+      return {
+        pnl: Number(formatUnits2(result[0], 6)),
+        fundingPayment: Number(formatUnits2(result[1], 6)),
+        effectiveMargin: Number(formatUnits2(result[2], 6)),
+        isLiquidatable: result[3]
+      };
+    }, `liveDetails for position ${this.positionId}`);
+  }
+};
+
+// src/functions/perp.ts
+function getPerpMark(perpData) {
+  return perpData.mark;
+}
+function getPerpIndex(perpData) {
+  return perpData.index;
+}
+function getPerpBeacon(perpData) {
+  return perpData.beacon;
+}
+function getPerpLastIndexUpdate(perpData) {
+  return perpData.lastIndexUpdate;
+}
+function getPerpOpenInterest(perpData) {
+  return perpData.openInterest;
+}
+function getPerpMarkTimeSeries(perpData) {
+  return perpData.markTimeSeries;
+}
+function getPerpIndexTimeSeries(perpData) {
+  return perpData.indexTimeSeries;
+}
+function getPerpFundingRate(perpData) {
+  return perpData.fundingRate;
+}
+function getPerpBounds(perpData) {
+  return perpData.bounds;
+}
+function getPerpFees(perpData) {
+  return perpData.fees;
+}
+function getPerpOpenInterestTimeSeries(perpData) {
+  return perpData.openInterestTimeSeries;
+}
+function getPerpFundingRateTimeSeries(perpData) {
+  return perpData.fundingRateTimeSeries;
+}
+function getPerpTickSpacing(perpData) {
+  return perpData.tickSpacing;
+}
+async function getAllMakerPositions(context, perpId) {
+  const query = `
+    query ($perpId: Bytes!) {
+      openPositions(
+        where: { perp: $perpId, isMaker: true }
+      ) {
+        perp { id }
+        inContractPosId
+        isLong
+        isMaker
+      }
+    }
+  `;
+  const response = await context.goldskyClient.request(query, { perpId });
+  return response.openPositions.map(
+    (position) => new OpenPosition(
+      context,
+      position.perp.id,
+      BigInt(position.inContractPosId),
+      position.isLong,
+      position.isMaker
+    )
+  );
+}
+async function getAllTakerPositions(context, perpId) {
+  const query = `
+    query ($perpId: Bytes!) {
+      openPositions(
+        where: { perp: $perpId, isMaker: false }
+      ) {
+        perp { id }
+        inContractPosId
+        isLong
+        isMaker
+      }
+    }
+  `;
+  const response = await context.goldskyClient.request(query, { perpId });
+  return response.openPositions.map(
+    (position) => new OpenPosition(
+      context,
+      position.perp.id,
+      BigInt(position.inContractPosId),
+      position.isLong,
+      position.isMaker
+    )
+  );
+}
+async function getTotalOpenMakerPnl(context, perpId) {
+  const positions = await getAllMakerPositions(context, perpId);
+  const liveDetails = await Promise.all(positions.map((position) => position.liveDetails()));
+  return liveDetails.reduce((acc, detail) => acc + detail.pnl - detail.fundingPayment, 0);
+}
+async function getTotalOpenTakerPnl(context, perpId) {
+  const positions = await getAllTakerPositions(context, perpId);
+  const liveDetails = await Promise.all(positions.map((position) => position.liveDetails()));
+  return liveDetails.reduce((acc, detail) => acc + detail.pnl - detail.fundingPayment, 0);
+}
+
+// src/functions/perp-manager.ts
+import { publicActions as publicActions3, decodeEventLog as decodeEventLog2 } from "viem";
+import { gql } from "graphql-request";
+import { parse as parse2 } from "graphql";
+async function getPerps(context) {
+  return withErrorHandling(async () => {
+    const query = parse2(gql`
+      {
+        perps {
+          id
+        }
+      }
+    `);
+    const response = await context.goldskyClient.request(query);
+    return response.perps.map((perpData) => perpData.id);
+  }, "getPerps");
+}
+async function createPerp(context, params) {
+  return withErrorHandling(async () => {
+    const sqrtPriceX96 = priceToSqrtPriceX96(params.startingPrice);
+    const contractParams = {
+      startingSqrtPriceX96: sqrtPriceX96,
+      beacon: params.beacon
+    };
+    const { request } = await context.walletClient.simulateContract({
+      address: context.deployments().perpManager,
+      abi: PERP_MANAGER_ABI,
+      functionName: "createPerp",
+      args: [contractParams],
+      account: context.walletClient.account
+    });
+    const txHash = await context.walletClient.writeContract(request);
+    const publicClient = context.walletClient.extend(publicActions3);
+    const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+    if (receipt.status === "reverted") {
+      throw new Error(`Transaction reverted. Hash: ${txHash}`);
+    }
+    for (const log of receipt.logs) {
+      try {
+        const decoded = decodeEventLog2({
+          abi: PERP_MANAGER_ABI,
+          data: log.data,
+          topics: log.topics,
+          eventName: "PerpCreated"
+        });
+        return decoded.args.perpId;
+      } catch (e) {
+        continue;
+      }
+    }
+    throw new Error("PerpCreated event not found in transaction receipt");
+  }, "createPerp");
+}
+async function openTakerPosition(context, perpId, params) {
+  return withErrorHandling(async () => {
+    const marginScaled = scale6Decimals(params.margin);
+    await approveUsdc(context, marginScaled);
+    const levX96 = scaleToX96(params.leverage);
+    const contractParams = {
+      isLong: params.isLong,
+      margin: marginScaled,
+      levX96,
+      unspecifiedAmountLimit: scale6Decimals(params.unspecifiedAmountLimit)
+    };
+    const { request } = await context.walletClient.simulateContract({
+      address: context.deployments().perpManager,
+      abi: PERP_MANAGER_ABI,
+      functionName: "openTakerPosition",
+      args: [perpId, contractParams],
+      account: context.walletClient.account
+    });
+    const txHash = await context.walletClient.writeContract(request);
+    const publicClient = context.walletClient.extend(publicActions3);
+    const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+    if (receipt.status === "reverted") {
+      throw new Error(`Transaction reverted. Hash: ${txHash}`);
+    }
+    let takerPosId = null;
+    for (const log of receipt.logs) {
+      try {
+        const decoded = decodeEventLog2({
+          abi: PERP_MANAGER_ABI,
+          data: log.data,
+          topics: log.topics,
+          eventName: "PositionOpened"
+        });
+        if (decoded.args.perpId === perpId && !decoded.args.isMaker) {
+          takerPosId = decoded.args.posId;
+          break;
+        }
+      } catch (e) {
+        continue;
+      }
+    }
+    if (!takerPosId) {
+      throw new Error(`PositionOpened event not found in transaction receipt. Hash: ${txHash}`);
+    }
+    return new OpenPosition(context, perpId, takerPosId, params.isLong, false);
+  }, "openTakerPosition");
+}
+async function openMakerPosition(context, perpId, params) {
+  return withErrorHandling(async () => {
+    const marginScaled = scale6Decimals(params.margin);
+    await approveUsdc(context, marginScaled);
+    const perpData = await context.getPerpData(perpId);
+    const tickLower = priceToTick(params.priceLower, true);
+    const tickUpper = priceToTick(params.priceUpper, false);
+    const tickSpacing = perpData.tickSpacing;
+    const alignedTickLower = Math.floor(tickLower / tickSpacing) * tickSpacing;
+    const alignedTickUpper = Math.ceil(tickUpper / tickSpacing) * tickSpacing;
+    const contractParams = {
+      margin: marginScaled,
+      liquidity: params.liquidity,
+      tickLower: alignedTickLower,
+      tickUpper: alignedTickUpper,
+      maxAmt0In: scale6Decimals(params.maxAmt0In),
+      maxAmt1In: scale6Decimals(params.maxAmt1In)
+    };
+    const { request } = await context.walletClient.simulateContract({
+      address: context.deployments().perpManager,
+      abi: PERP_MANAGER_ABI,
+      functionName: "openMakerPosition",
+      args: [perpId, contractParams],
+      account: context.walletClient.account
+    });
+    const txHash = await context.walletClient.writeContract(request);
+    const publicClient = context.walletClient.extend(publicActions3);
+    const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+    if (receipt.status === "reverted") {
+      throw new Error(`Transaction reverted. Hash: ${txHash}`);
+    }
+    let makerPosId = null;
+    for (const log of receipt.logs) {
+      try {
+        const decoded = decodeEventLog2({
+          abi: PERP_MANAGER_ABI,
+          data: log.data,
+          topics: log.topics,
+          eventName: "PositionOpened"
+        });
+        if (decoded.args.perpId === perpId && decoded.args.isMaker) {
+          makerPosId = decoded.args.posId;
+          break;
+        }
+      } catch (e) {
+        continue;
+      }
+    }
+    if (!makerPosId) {
+      throw new Error(`PositionOpened event not found in transaction receipt. Hash: ${txHash}`);
+    }
+    return new OpenPosition(context, perpId, makerPosId, void 0, true);
+  }, "openMakerPosition");
+}
+
+// src/functions/user.ts
+function getUserUsdcBalance(userData) {
+  return userData.usdcBalance;
+}
+function getUserOpenPositions(userData) {
+  return userData.openPositions;
+}
+function getUserClosedPositions(userData) {
+  return userData.closedPositions;
+}
+function getUserRealizedPnl(userData) {
+  return userData.realizedPnl;
+}
+function getUserUnrealizedPnl(userData) {
+  return userData.unrealizedPnl;
+}
+function getUserWalletAddress(userData) {
+  return userData.walletAddress;
+}
+
+// src/functions/position.ts
+import { formatUnits as formatUnits3, decodeEventLog as decodeEventLog3 } from "viem";
+import { publicActions as publicActions4 } from "viem";
+function getPositionPerpId(positionData) {
+  return positionData.perpId;
+}
+function getPositionId(positionData) {
+  return positionData.positionId;
+}
+function getPositionIsLong(positionData) {
+  return positionData.isLong;
+}
+function getPositionIsMaker(positionData) {
+  return positionData.isMaker;
+}
+function getPositionLiveDetails(positionData) {
+  return positionData.liveDetails;
+}
+function getPositionPnl(positionData) {
+  return positionData.liveDetails.pnl;
+}
+function getPositionFundingPayment(positionData) {
+  return positionData.liveDetails.fundingPayment;
+}
+function getPositionEffectiveMargin(positionData) {
+  return positionData.liveDetails.effectiveMargin;
+}
+function getPositionIsLiquidatable(positionData) {
+  return positionData.liveDetails.isLiquidatable;
+}
+async function closePosition(context, perpId, positionId, params) {
+  return withErrorHandling(async () => {
+    const contractParams = {
+      posId: positionId,
+      minAmt0Out: scale6Decimals(params.minAmt0Out),
+      minAmt1Out: scale6Decimals(params.minAmt1Out),
+      maxAmt1In: scale6Decimals(params.maxAmt1In)
+    };
+    const { result, request } = await context.walletClient.extend(publicActions4).simulateContract({
+      address: context.deployments().perpManager,
+      abi: PERP_MANAGER_ABI,
+      functionName: "closePosition",
+      args: [perpId, contractParams],
+      account: context.walletClient.account
+    });
+    const txHash = await context.walletClient.writeContract(request);
+    const publicClient = context.walletClient.extend(publicActions4);
+    const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+    if (receipt.status === "reverted") {
+      throw new Error(`Transaction reverted. Hash: ${txHash}`);
+    }
+    let newPositionId = null;
+    for (const log of receipt.logs) {
+      try {
+        const decoded = decodeEventLog3({
+          abi: PERP_MANAGER_ABI,
+          data: log.data,
+          topics: log.topics,
+          eventName: "PositionOpened"
+        });
+        if (decoded.args.perpId === perpId) {
+          newPositionId = decoded.args.posId;
+          break;
+        }
+      } catch (e) {
+        continue;
+      }
+    }
+    if (!newPositionId) {
+      return null;
+    }
+    return {
+      perpId,
+      positionId: newPositionId,
+      liveDetails: await getPositionLiveDetailsFromContract(context, perpId, newPositionId)
+    };
+  }, `closePosition for position ${positionId}`);
+}
+async function getPositionLiveDetailsFromContract(context, perpId, positionId) {
+  return withErrorHandling(async () => {
+    const result = await context.walletClient.readContract({
+      address: context.deployments().perpManager,
+      abi: PERP_MANAGER_ABI,
+      functionName: "livePositionDetails",
+      args: [perpId, positionId]
+    });
+    return {
+      pnl: Number(formatUnits3(result[0], 6)),
+      fundingPayment: Number(formatUnits3(result[1], 6)),
+      effectiveMargin: Number(formatUnits3(result[2], 6)),
+      isLiquidatable: result[3]
+    };
+  }, `getPositionLiveDetailsFromContract for position ${positionId}`);
+}
 export {
   BEACON_ABI,
   BIGINT_1E6,
-  DEPLOYMENTS,
+  ContractError,
+  GraphQLError,
+  InsufficientFundsError,
   NUMBER_1E6,
   OpenPosition,
   PERP_MANAGER_ABI,
-  Perp,
   PerpCityContext,
-  PerpManager,
+  PerpCityError,
   Q96,
-  User,
+  RPCError,
+  TransactionRejectedError,
+  ValidationError,
   approveUsdc,
+  closePosition,
+  createPerp,
   estimateLiquidity,
+  getAllMakerPositions,
+  getAllTakerPositions,
+  getPerpBeacon,
+  getPerpBounds,
+  getPerpFees,
+  getPerpFundingRate,
+  getPerpFundingRateTimeSeries,
+  getPerpIndex,
+  getPerpIndexTimeSeries,
+  getPerpLastIndexUpdate,
+  getPerpMark,
+  getPerpMarkTimeSeries,
+  getPerpOpenInterest,
+  getPerpOpenInterestTimeSeries,
+  getPerpTickSpacing,
+  getPerps,
+  getPositionEffectiveMargin,
+  getPositionFundingPayment,
+  getPositionId,
+  getPositionIsLiquidatable,
+  getPositionIsLong,
+  getPositionIsMaker,
+  getPositionLiveDetails,
+  getPositionLiveDetailsFromContract,
+  getPositionPerpId,
+  getPositionPnl,
+  getTotalOpenMakerPnl,
+  getTotalOpenTakerPnl,
+  getUserClosedPositions,
+  getUserOpenPositions,
+  getUserRealizedPnl,
+  getUserUnrealizedPnl,
+  getUserUsdcBalance,
+  getUserWalletAddress,
   marginRatioToLeverage,
+  openMakerPosition,
+  openTakerPosition,
+  parseContractError,
   priceToSqrtPriceX96,
   priceToTick,
   scale6Decimals,
   scaleFrom6Decimals,
   scaleFromX96,
   scaleToX96,
-  sqrtPriceX96ToPrice
+  sqrtPriceX96ToPrice,
+  withErrorHandling
 };
 //# sourceMappingURL=index.mjs.map