opentool 0.18.0 → 0.19.0

package/dist/adapters/polymarket/index.d.ts

@@ -187,20 +187,16 @@ interface PolymarketPlaceOrderResponse {
     message?: string;
     [key: string]: unknown;
 }
-declare function createPolymarketApiKey(args: {
+interface PolymarketApiKeyRequestArgs {
     wallet: WalletFullContext;
     environment?: PolymarketEnvironment;
     timestamp?: number;
     nonce?: number;
     message?: string;
-}): Promise<PolymarketApiKeyResponse>;
-declare function derivePolymarketApiKey(args: {
-    wallet: WalletFullContext;
-    environment?: PolymarketEnvironment;
-    timestamp?: number;
-    nonce?: number;
-    message?: string;
-}): Promise<PolymarketApiKeyResponse>;
+}
+declare function createPolymarketApiKey(args: PolymarketApiKeyRequestArgs): Promise<PolymarketApiKeyResponse>;
+declare function derivePolymarketApiKey(args: PolymarketApiKeyRequestArgs): Promise<PolymarketApiKeyResponse>;
+declare function createOrDerivePolymarketApiKey(args: PolymarketApiKeyRequestArgs): Promise<PolymarketApiKeyResponse>;
 declare function placePolymarketOrder(args: {
     wallet: WalletFullContext;
     credentials?: PolymarketApiCredentials;
@@ -253,6 +249,8 @@ declare class PolymarketExchangeClient {
     cancelMarket(tokenId: string): Promise<Record<string, unknown>>;
 }
 
+type CsvStringInput = string | string[];
+type CsvNumberInput = number | number[];
 type FetchParams = {
     environment?: PolymarketEnvironment;
     limit?: number;
@@ -267,6 +265,135 @@ type FetchParams = {
     active?: boolean;
     closed?: boolean;
 };
+interface PolymarketUserPosition {
+    proxyWallet?: string | null;
+    asset?: string | null;
+    conditionId?: string | null;
+    size?: number | null;
+    avgPrice?: number | null;
+    initialValue?: number | null;
+    currentValue?: number | null;
+    cashPnl?: number | null;
+    percentPnl?: number | null;
+    totalBought?: number | null;
+    realizedPnl?: number | null;
+    percentRealizedPnl?: number | null;
+    curPrice?: number | null;
+    redeemable?: boolean;
+    mergeable?: boolean;
+    title?: string | null;
+    slug?: string | null;
+    icon?: string | null;
+    eventSlug?: string | null;
+    outcome?: string | null;
+    outcomeIndex?: number | null;
+    oppositeOutcome?: string | null;
+    oppositeAsset?: string | null;
+    endDate?: string | null;
+    negativeRisk?: boolean;
+}
+interface PolymarketClosedPosition {
+    proxyWallet?: string | null;
+    asset?: string | null;
+    conditionId?: string | null;
+    avgPrice?: number | null;
+    totalBought?: number | null;
+    realizedPnl?: number | null;
+    curPrice?: number | null;
+    timestamp?: number | null;
+    title?: string | null;
+    slug?: string | null;
+    icon?: string | null;
+    eventSlug?: string | null;
+    outcome?: string | null;
+    outcomeIndex?: number | null;
+    oppositeOutcome?: string | null;
+    oppositeAsset?: string | null;
+    endDate?: string | null;
+}
+type PolymarketActivityType = "TRADE" | "SPLIT" | "MERGE" | "REDEEM" | "REWARD" | "CONVERSION" | "MAKER_REBATE";
+interface PolymarketUserActivity {
+    proxyWallet?: string | null;
+    timestamp?: number | null;
+    conditionId?: string | null;
+    type?: PolymarketActivityType | null;
+    size?: number | null;
+    usdcSize?: number | null;
+    transactionHash?: string | null;
+    price?: number | null;
+    asset?: string | null;
+    side?: "BUY" | "SELL" | null;
+    outcomeIndex?: number | null;
+    title?: string | null;
+    slug?: string | null;
+    icon?: string | null;
+    eventSlug?: string | null;
+    outcome?: string | null;
+    name?: string | null;
+    pseudonym?: string | null;
+    bio?: string | null;
+    profileImage?: string | null;
+    profileImageOptimized?: string | null;
+}
+interface PolymarketPositionValue {
+    user?: string | null;
+    value?: number | null;
+}
+interface PolymarketPublicProfileUser {
+    id?: string | null;
+    creator?: boolean;
+    mod?: boolean;
+}
+interface PolymarketPublicProfile {
+    createdAt?: string | null;
+    proxyWallet?: string | null;
+    profileImage?: string | null;
+    displayUsernamePublic?: boolean | null;
+    bio?: string | null;
+    pseudonym?: string | null;
+    name?: string | null;
+    users?: PolymarketPublicProfileUser[] | null;
+    xUsername?: string | null;
+    verifiedBadge?: boolean | null;
+}
+interface PolymarketUserQueryBase {
+    user: string;
+    environment?: PolymarketEnvironment;
+    market?: CsvStringInput;
+    eventId?: CsvNumberInput;
+}
+interface PolymarketUserPositionParams extends PolymarketUserQueryBase {
+    sizeThreshold?: number;
+    redeemable?: boolean;
+    mergeable?: boolean;
+    limit?: number;
+    offset?: number;
+    sortBy?: "CURRENT" | "INITIAL" | "TOKENS" | "CASHPNL" | "PERCENTPNL" | "TITLE" | "RESOLVING" | "PRICE" | "AVGPRICE";
+    sortDirection?: "ASC" | "DESC";
+    title?: string;
+}
+interface PolymarketClosedPositionParams extends PolymarketUserQueryBase {
+    limit?: number;
+    offset?: number;
+    sortBy?: "REALIZEDPNL" | "TITLE" | "PRICE" | "AVGPRICE" | "TIMESTAMP";
+    sortDirection?: "ASC" | "DESC";
+    title?: string;
+}
+interface PolymarketUserActivityParams extends PolymarketUserQueryBase {
+    limit?: number;
+    offset?: number;
+    type?: PolymarketActivityType | PolymarketActivityType[];
+    start?: number;
+    end?: number;
+    sortBy?: "TIMESTAMP" | "TOKENS" | "CASH";
+    sortDirection?: "ASC" | "DESC";
+    side?: "BUY" | "SELL";
+}
+interface PolymarketPositionValueParams {
+    user: string;
+    environment?: PolymarketEnvironment;
+    market?: CsvStringInput;
+}
 declare class PolymarketInfoClient {
     private readonly environment;
     constructor(environment?: PolymarketEnvironment);
@@ -286,6 +413,11 @@ declare class PolymarketInfoClient {
         interval?: string;
         fidelity?: number;
     }): Promise<PolymarketPriceHistoryPoint[]>;
+    positions(params: Omit<PolymarketUserPositionParams, "environment">): Promise<PolymarketUserPosition[]>;
+    closedPositions(params: Omit<PolymarketClosedPositionParams, "environment">): Promise<PolymarketClosedPosition[]>;
+    activity(params: Omit<PolymarketUserActivityParams, "environment">): Promise<PolymarketUserActivity[]>;
+    positionValue(params: Omit<PolymarketPositionValueParams, "environment">): Promise<PolymarketPositionValue[]>;
+    publicProfile(address: string): Promise<PolymarketPublicProfile | null>;
 }
 declare function fetchPolymarketMarkets(params?: FetchParams): Promise<PolymarketMarket[]>;
 declare function fetchPolymarketMarket(params: {
@@ -315,5 +447,13 @@ declare function fetchPolymarketPriceHistory(params: {
     fidelity?: number;
     environment?: PolymarketEnvironment;
 }): Promise<PolymarketPriceHistoryPoint[]>;
+declare function fetchPolymarketPositions(params: PolymarketUserPositionParams): Promise<PolymarketUserPosition[]>;
+declare function fetchPolymarketClosedPositions(params: PolymarketClosedPositionParams): Promise<PolymarketClosedPosition[]>;
+declare function fetchPolymarketActivity(params: PolymarketUserActivityParams): Promise<PolymarketUserActivity[]>;
+declare function fetchPolymarketPositionValue(params: PolymarketPositionValueParams): Promise<PolymarketPositionValue[]>;
+declare function fetchPolymarketPublicProfile(params: {
+    address: string;
+    environment?: PolymarketEnvironment;
+}): Promise<PolymarketPublicProfile | null>;
 
-export { POLYMARKET_CHAIN_ID, POLYMARKET_CLOB_AUTH_DOMAIN, POLYMARKET_CLOB_DOMAIN, POLYMARKET_ENDPOINTS, POLYMARKET_EXCHANGE_ADDRESSES, type PolymarketApiCredentials, PolymarketApiError, type PolymarketApiKeyResponse, PolymarketAuthError, type PolymarketEnvironment, PolymarketExchangeClient, PolymarketInfoClient, type PolymarketMarket, type PolymarketOrderIntent, type PolymarketOrderType, type PolymarketOrderbook, type PolymarketPlaceOrderResponse, type PolymarketPriceHistoryPoint, type PolymarketSide, type PolymarketSignatureType, type PolymarketSignedOrderPayload, buildHmacSignature, buildL1Headers, buildL2Headers, buildPolymarketOrderAmounts, buildSignedOrderPayload, cancelAllPolymarketOrders, cancelMarketPolymarketOrders, cancelPolymarketOrder, cancelPolymarketOrders, createPolymarketApiKey, derivePolymarketApiKey, fetchPolymarketMarket, fetchPolymarketMarkets, fetchPolymarketMidpoint, fetchPolymarketOrderbook, fetchPolymarketPrice, fetchPolymarketPriceHistory, normalizeNumberArrayish, normalizeStringArrayish, placePolymarketOrder, resolveExchangeAddress, resolvePolymarketBaseUrl };
+export { POLYMARKET_CHAIN_ID, POLYMARKET_CLOB_AUTH_DOMAIN, POLYMARKET_CLOB_DOMAIN, POLYMARKET_ENDPOINTS, POLYMARKET_EXCHANGE_ADDRESSES, type PolymarketActivityType, type PolymarketApiCredentials, PolymarketApiError, type PolymarketApiKeyResponse, PolymarketAuthError, type PolymarketClosedPosition, type PolymarketClosedPositionParams, type PolymarketEnvironment, PolymarketExchangeClient, PolymarketInfoClient, type PolymarketMarket, type PolymarketOrderIntent, type PolymarketOrderType, type PolymarketOrderbook, type PolymarketPlaceOrderResponse, type PolymarketPositionValue, type PolymarketPositionValueParams, type PolymarketPriceHistoryPoint, type PolymarketPublicProfile, type PolymarketPublicProfileUser, type PolymarketSide, type PolymarketSignatureType, type PolymarketSignedOrderPayload, type PolymarketUserActivity, type PolymarketUserActivityParams, type PolymarketUserPosition, type PolymarketUserPositionParams, buildHmacSignature, buildL1Headers, buildL2Headers, buildPolymarketOrderAmounts, buildSignedOrderPayload, cancelAllPolymarketOrders, cancelMarketPolymarketOrders, cancelPolymarketOrder, cancelPolymarketOrders, createOrDerivePolymarketApiKey, createPolymarketApiKey, derivePolymarketApiKey, fetchPolymarketActivity, fetchPolymarketClosedPositions, fetchPolymarketMarket, fetchPolymarketMarkets, fetchPolymarketMidpoint, fetchPolymarketOrderbook, fetchPolymarketPositionValue, fetchPolymarketPositions, fetchPolymarketPrice, fetchPolymarketPriceHistory, fetchPolymarketPublicProfile, normalizeNumberArrayish, normalizeStringArrayish, placePolymarketOrder, resolveExchangeAddress, resolvePolymarketBaseUrl };

package/dist/adapters/polymarket/index.js

@@ -315,7 +315,7 @@ async function buildSignedOrderPayload(args) {
 // src/adapters/polymarket/exchange.ts
 async function resolveAuthContext(args) {
   if (args.wallet) {
-    const credentials = args.credentials ?? await createPolymarketApiKey({
+    const credentials = args.credentials ?? await createOrDerivePolymarketApiKey({
       wallet: args.wallet,
       ...args.environment ? { environment: args.environment } : {}
     });
@@ -352,27 +352,9 @@ function resolvePath(url) {
   const parsed = new URL(url);
   return `${parsed.pathname}${parsed.search}`;
 }
-async function createPolymarketApiKey(args) {
-  const environment = args.environment ?? "mainnet";
-  const baseUrl = resolvePolymarketBaseUrl("clob", environment);
-  const url = `${baseUrl}/auth/api-key`;
-  const headers = await buildL1Headers({
-    wallet: args.wallet,
-    environment,
-    ...args.timestamp !== void 0 ? { timestamp: args.timestamp } : {},
-    ...args.nonce !== void 0 ? { nonce: args.nonce } : {},
-    ...args.message !== void 0 ? { message: args.message } : {}
-  });
-  const data = await requestJson(url, {
-    method: "POST",
-    headers: {
-      "content-type": "application/json",
-      ...headers
-    },
-    body: JSON.stringify({})
-  });
+function normalizeApiKeyResponse(data) {
   if (!data?.apiKey || !data?.secret || !data?.passphrase) {
-    throw new PolymarketAuthError("Failed to create Polymarket API key.");
+    return null;
   }
   return {
     apiKey: data.apiKey,
@@ -380,10 +362,10 @@ async function createPolymarketApiKey(args) {
     passphrase: data.passphrase
   };
 }
-async function derivePolymarketApiKey(args) {
+async function requestPolymarketApiKey(args) {
   const environment = args.environment ?? "mainnet";
   const baseUrl = resolvePolymarketBaseUrl("clob", environment);
-  const url = `${baseUrl}/auth/derive-api-key`;
+  const url = args.mode === "create" ? `${baseUrl}/auth/api-key` : `${baseUrl}/auth/derive-api-key`;
   const headers = await buildL1Headers({
     wallet: args.wallet,
     environment,
@@ -391,21 +373,41 @@ async function derivePolymarketApiKey(args) {
     ...args.nonce !== void 0 ? { nonce: args.nonce } : {},
     ...args.message !== void 0 ? { message: args.message } : {}
   });
-  const data = await requestJson(url, {
-    method: "GET",
+  return await requestJson(url, {
+    method: args.mode === "create" ? "POST" : "GET",
     headers: {
       "content-type": "application/json",
       ...headers
-    }
+    },
+    ...args.mode === "create" ? { body: JSON.stringify({}) } : {}
   });
-  if (!data?.apiKey || !data?.secret || !data?.passphrase) {
+}
+async function createPolymarketApiKey(args) {
+  const normalized = normalizeApiKeyResponse(
+    await requestPolymarketApiKey({ ...args, mode: "create" })
+  );
+  if (!normalized) {
+    throw new PolymarketAuthError("Failed to create Polymarket API key.");
+  }
+  return normalized;
+}
+async function derivePolymarketApiKey(args) {
+  const normalized = normalizeApiKeyResponse(
+    await requestPolymarketApiKey({ ...args, mode: "derive" })
+  );
+  if (!normalized) {
     throw new PolymarketAuthError("Failed to derive Polymarket API key.");
   }
-  return {
-    apiKey: data.apiKey,
-    secret: data.secret,
-    passphrase: data.passphrase
-  };
+  return normalized;
+}
+async function createOrDerivePolymarketApiKey(args) {
+  const created = normalizeApiKeyResponse(
+    await requestPolymarketApiKey({ ...args, mode: "create" })
+  );
+  if (created) {
+    return created;
+  }
+  return derivePolymarketApiKey(args);
 }
 async function placePolymarketOrder(args) {
   const environment = args.environment ?? "mainnet";
@@ -634,6 +636,61 @@ function getString(value) {
   const str = String(value).trim();
   return str.length ? str : null;
 }
+function getNumber(value) {
+  const numeric = Number(value);
+  return Number.isFinite(numeric) ? numeric : null;
+}
+function getInteger(value) {
+  const numeric = getNumber(value);
+  return numeric == null ? null : Math.trunc(numeric);
+}
+function getBoolean(value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "true") return true;
+    if (normalized === "false") return false;
+  }
+  return null;
+}
+function normalizeCsvStringInput(value) {
+  if (Array.isArray(value)) {
+    return value.flatMap((entry) => String(entry).split(",")).map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+  }
+  if (typeof value === "string") {
+    return value.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+  }
+  return [];
+}
+function normalizeCsvNumberInput(value) {
+  if (Array.isArray(value)) {
+    return value.filter((entry) => Number.isFinite(entry));
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return [value];
+  }
+  return [];
+}
+function appendCsvParam(url, key, values) {
+  if (values.length > 0) {
+    url.searchParams.set(key, values.join(","));
+  }
+}
+function appendNumberParam(url, key, value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    url.searchParams.set(key, String(value));
+  }
+}
+function appendBooleanParam(url, key, value) {
+  if (typeof value === "boolean") {
+    url.searchParams.set(key, value ? "true" : "false");
+  }
+}
+function assertMutuallyExclusiveMarketScope(market, eventIds) {
+  if (market.length > 0 && eventIds.length > 0) {
+    throw new Error("market and eventId are mutually exclusive.");
+  }
+}
 function normalizeOrderbookLevels(raw) {
   if (!Array.isArray(raw)) return [];
   return raw.map((entry) => {
@@ -697,6 +754,132 @@ function normalizeGammaMarket(market, event) {
   }
   return normalized;
 }
+function normalizeUserPosition(raw) {
+  const record = raw && typeof raw === "object" ? raw : {};
+  const normalized = {
+    proxyWallet: getString(record.proxyWallet),
+    asset: getString(record.asset),
+    conditionId: getString(record.conditionId),
+    size: getNumber(record.size),
+    avgPrice: getNumber(record.avgPrice),
+    initialValue: getNumber(record.initialValue),
+    currentValue: getNumber(record.currentValue),
+    cashPnl: getNumber(record.cashPnl),
+    percentPnl: getNumber(record.percentPnl),
+    totalBought: getNumber(record.totalBought),
+    realizedPnl: getNumber(record.realizedPnl),
+    percentRealizedPnl: getNumber(record.percentRealizedPnl),
+    curPrice: getNumber(record.curPrice),
+    title: getString(record.title),
+    slug: getString(record.slug),
+    icon: getString(record.icon),
+    eventSlug: getString(record.eventSlug),
+    outcome: getString(record.outcome),
+    outcomeIndex: getInteger(record.outcomeIndex),
+    oppositeOutcome: getString(record.oppositeOutcome),
+    oppositeAsset: getString(record.oppositeAsset),
+    endDate: parseOptionalDate(record.endDate)
+  };
+  const redeemable = getBoolean(record.redeemable);
+  if (redeemable != null) normalized.redeemable = redeemable;
+  const mergeable = getBoolean(record.mergeable);
+  if (mergeable != null) normalized.mergeable = mergeable;
+  const negativeRisk = getBoolean(record.negativeRisk);
+  if (negativeRisk != null) normalized.negativeRisk = negativeRisk;
+  return normalized;
+}
+function normalizeClosedPosition(raw) {
+  const record = raw && typeof raw === "object" ? raw : {};
+  return {
+    proxyWallet: getString(record.proxyWallet),
+    asset: getString(record.asset),
+    conditionId: getString(record.conditionId),
+    avgPrice: getNumber(record.avgPrice),
+    totalBought: getNumber(record.totalBought),
+    realizedPnl: getNumber(record.realizedPnl),
+    curPrice: getNumber(record.curPrice),
+    timestamp: getInteger(record.timestamp),
+    title: getString(record.title),
+    slug: getString(record.slug),
+    icon: getString(record.icon),
+    eventSlug: getString(record.eventSlug),
+    outcome: getString(record.outcome),
+    outcomeIndex: getInteger(record.outcomeIndex),
+    oppositeOutcome: getString(record.oppositeOutcome),
+    oppositeAsset: getString(record.oppositeAsset),
+    endDate: parseOptionalDate(record.endDate)
+  };
+}
+function normalizeUserActivity(raw) {
+  const record = raw && typeof raw === "object" ? raw : {};
+  return {
+    proxyWallet: getString(record.proxyWallet),
+    timestamp: getInteger(record.timestamp),
+    conditionId: getString(record.conditionId),
+    type: getString(record.type),
+    size: getNumber(record.size),
+    usdcSize: getNumber(record.usdcSize),
+    transactionHash: getString(record.transactionHash),
+    price: getNumber(record.price),
+    asset: getString(record.asset),
+    side: getString(record.side),
+    outcomeIndex: getInteger(record.outcomeIndex),
+    title: getString(record.title),
+    slug: getString(record.slug),
+    icon: getString(record.icon),
+    eventSlug: getString(record.eventSlug),
+    outcome: getString(record.outcome),
+    name: getString(record.name),
+    pseudonym: getString(record.pseudonym),
+    bio: getString(record.bio),
+    profileImage: getString(record.profileImage),
+    profileImageOptimized: getString(record.profileImageOptimized)
+  };
+}
+function normalizePositionValue(raw) {
+  const record = raw && typeof raw === "object" ? raw : {};
+  return {
+    user: getString(record.user),
+    value: getNumber(record.value)
+  };
+}
+function normalizeProfileUsers(raw) {
+  if (!Array.isArray(raw)) return null;
+  return raw.map((entry) => {
+    const record = entry && typeof entry === "object" ? entry : {};
+    const normalized = {
+      id: getString(record.id)
+    };
+    const creator = getBoolean(record.creator);
+    if (creator != null) normalized.creator = creator;
+    const mod = getBoolean(record.mod);
+    if (mod != null) normalized.mod = mod;
+    return normalized;
+  });
+}
+function normalizePublicProfile(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const record = raw;
+  const normalized = {
+    createdAt: parseOptionalDate(record.createdAt),
+    proxyWallet: getString(record.proxyWallet),
+    profileImage: getString(record.profileImage),
+    bio: getString(record.bio),
+    pseudonym: getString(record.pseudonym),
+    name: getString(record.name),
+    users: normalizeProfileUsers(record.users),
+    xUsername: getString(record.xUsername)
+  };
+  const displayUsernamePublic = getBoolean(record.displayUsernamePublic);
+  if (displayUsernamePublic != null) {
+    normalized.displayUsernamePublic = displayUsernamePublic;
+  }
+  const verifiedBadge = getBoolean(record.verifiedBadge);
+  if (verifiedBadge != null) {
+    normalized.verifiedBadge = verifiedBadge;
+  }
+  return normalized;
+}
 var PolymarketInfoClient = class {
   constructor(environment = "mainnet") {
     this.environment = environment;
@@ -719,6 +902,21 @@ var PolymarketInfoClient = class {
   priceHistory(params) {
     return fetchPolymarketPriceHistory({ ...params, environment: this.environment });
   }
+  positions(params) {
+    return fetchPolymarketPositions({ ...params, environment: this.environment });
+  }
+  closedPositions(params) {
+    return fetchPolymarketClosedPositions({ ...params, environment: this.environment });
+  }
+  activity(params) {
+    return fetchPolymarketActivity({ ...params, environment: this.environment });
+  }
+  positionValue(params) {
+    return fetchPolymarketPositionValue({ ...params, environment: this.environment });
+  }
+  publicProfile(address) {
+    return fetchPolymarketPublicProfile({ address, environment: this.environment });
+  }
 };
 async function fetchPolymarketMarkets(params = {}) {
   if (params.active !== void 0 && params.active !== true) {
@@ -825,7 +1023,97 @@ async function fetchPolymarketPriceHistory(params) {
     p: Number(point.p)
   })).filter((point) => Number.isFinite(point.t) && Number.isFinite(point.p));
 }
+async function fetchPolymarketPositions(params) {
+  const environment = params.environment ?? "mainnet";
+  const market = normalizeCsvStringInput(params.market);
+  const eventIds = normalizeCsvNumberInput(params.eventId);
+  assertMutuallyExclusiveMarketScope(market, eventIds);
+  const baseUrl = resolvePolymarketBaseUrl("data", environment);
+  const url = new URL("/positions", baseUrl);
+  url.searchParams.set("user", params.user);
+  appendCsvParam(url, "market", market);
+  appendCsvParam(
+    url,
+    "eventId",
+    eventIds.map((entry) => String(entry))
+  );
+  appendNumberParam(url, "sizeThreshold", params.sizeThreshold);
+  appendBooleanParam(url, "redeemable", params.redeemable);
+  appendBooleanParam(url, "mergeable", params.mergeable);
+  appendNumberParam(url, "limit", params.limit);
+  appendNumberParam(url, "offset", params.offset);
+  if (params.sortBy) url.searchParams.set("sortBy", params.sortBy);
+  if (params.sortDirection) url.searchParams.set("sortDirection", params.sortDirection);
+  if (params.title) url.searchParams.set("title", params.title);
+  const data = await requestJson2(url.toString());
+  return Array.isArray(data) ? data.map((entry) => normalizeUserPosition(entry)) : [];
+}
+async function fetchPolymarketClosedPositions(params) {
+  const environment = params.environment ?? "mainnet";
+  const market = normalizeCsvStringInput(params.market);
+  const eventIds = normalizeCsvNumberInput(params.eventId);
+  assertMutuallyExclusiveMarketScope(market, eventIds);
+  const baseUrl = resolvePolymarketBaseUrl("data", environment);
+  const url = new URL("/closed-positions", baseUrl);
+  url.searchParams.set("user", params.user);
+  appendCsvParam(url, "market", market);
+  appendCsvParam(
+    url,
+    "eventId",
+    eventIds.map((entry) => String(entry))
+  );
+  appendNumberParam(url, "limit", params.limit);
+  appendNumberParam(url, "offset", params.offset);
+  if (params.sortBy) url.searchParams.set("sortBy", params.sortBy);
+  if (params.sortDirection) url.searchParams.set("sortDirection", params.sortDirection);
+  if (params.title) url.searchParams.set("title", params.title);
+  const data = await requestJson2(url.toString());
+  return Array.isArray(data) ? data.map((entry) => normalizeClosedPosition(entry)) : [];
+}
+async function fetchPolymarketActivity(params) {
+  const environment = params.environment ?? "mainnet";
+  const market = normalizeCsvStringInput(params.market);
+  const eventIds = normalizeCsvNumberInput(params.eventId);
+  assertMutuallyExclusiveMarketScope(market, eventIds);
+  const types = Array.isArray(params.type) ? params.type : params.type ? [params.type] : [];
+  const baseUrl = resolvePolymarketBaseUrl("data", environment);
+  const url = new URL("/activity", baseUrl);
+  url.searchParams.set("user", params.user);
+  appendCsvParam(url, "market", market);
+  appendCsvParam(
+    url,
+    "eventId",
+    eventIds.map((entry) => String(entry))
+  );
+  appendCsvParam(url, "type", types);
+  appendNumberParam(url, "start", params.start);
+  appendNumberParam(url, "end", params.end);
+  appendNumberParam(url, "limit", params.limit);
+  appendNumberParam(url, "offset", params.offset);
+  if (params.sortBy) url.searchParams.set("sortBy", params.sortBy);
+  if (params.sortDirection) url.searchParams.set("sortDirection", params.sortDirection);
+  if (params.side) url.searchParams.set("side", params.side);
+  const data = await requestJson2(url.toString());
+  return Array.isArray(data) ? data.map((entry) => normalizeUserActivity(entry)) : [];
+}
+async function fetchPolymarketPositionValue(params) {
+  const environment = params.environment ?? "mainnet";
+  const baseUrl = resolvePolymarketBaseUrl("data", environment);
+  const url = new URL("/value", baseUrl);
+  url.searchParams.set("user", params.user);
+  appendCsvParam(url, "market", normalizeCsvStringInput(params.market));
+  const data = await requestJson2(url.toString());
+  return Array.isArray(data) ? data.map((entry) => normalizePositionValue(entry)) : [];
+}
+async function fetchPolymarketPublicProfile(params) {
+  const environment = params.environment ?? "mainnet";
+  const baseUrl = resolvePolymarketBaseUrl("gamma", environment);
+  const url = new URL("/public-profile", baseUrl);
+  url.searchParams.set("address", params.address);
+  const data = await requestJson2(url.toString());
+  return normalizePublicProfile(data);
+}
 
-export { POLYMARKET_CHAIN_ID, POLYMARKET_CLOB_AUTH_DOMAIN, POLYMARKET_CLOB_DOMAIN, POLYMARKET_ENDPOINTS, POLYMARKET_EXCHANGE_ADDRESSES, PolymarketApiError, PolymarketAuthError, PolymarketExchangeClient, PolymarketInfoClient, buildHmacSignature, buildL1Headers, buildL2Headers, buildPolymarketOrderAmounts, buildSignedOrderPayload, cancelAllPolymarketOrders, cancelMarketPolymarketOrders, cancelPolymarketOrder, cancelPolymarketOrders, createPolymarketApiKey, derivePolymarketApiKey, fetchPolymarketMarket, fetchPolymarketMarkets, fetchPolymarketMidpoint, fetchPolymarketOrderbook, fetchPolymarketPrice, fetchPolymarketPriceHistory, normalizeNumberArrayish, normalizeStringArrayish, placePolymarketOrder, resolveExchangeAddress, resolvePolymarketBaseUrl };
+export { POLYMARKET_CHAIN_ID, POLYMARKET_CLOB_AUTH_DOMAIN, POLYMARKET_CLOB_DOMAIN, POLYMARKET_ENDPOINTS, POLYMARKET_EXCHANGE_ADDRESSES, PolymarketApiError, PolymarketAuthError, PolymarketExchangeClient, PolymarketInfoClient, buildHmacSignature, buildL1Headers, buildL2Headers, buildPolymarketOrderAmounts, buildSignedOrderPayload, cancelAllPolymarketOrders, cancelMarketPolymarketOrders, cancelPolymarketOrder, cancelPolymarketOrders, createOrDerivePolymarketApiKey, createPolymarketApiKey, derivePolymarketApiKey, fetchPolymarketActivity, fetchPolymarketClosedPositions, fetchPolymarketMarket, fetchPolymarketMarkets, fetchPolymarketMidpoint, fetchPolymarketOrderbook, fetchPolymarketPositionValue, fetchPolymarketPositions, fetchPolymarketPrice, fetchPolymarketPriceHistory, fetchPolymarketPublicProfile, normalizeNumberArrayish, normalizeStringArrayish, placePolymarketOrder, resolveExchangeAddress, resolvePolymarketBaseUrl };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map