@liberfi.io/react-predict 0.1.20 → 0.1.22

package/dist/index.js

@@ -108,13 +108,19 @@ var PredictClient = class {
   // Positions
   // -------------------------------------------------------------------------
   /**
-   * Maps to `GET /api/v1/positions?source=...&user=...`.
+   * Maps to `GET /api/v1/positions`.
    *
-   * @param user - Wallet address.
-   * @param source - Provider source. Omit to aggregate all providers.
+   * Single-source: `getPositions("addr", "kalshi")`.
+   * Multi-wallet:  `getPositions({ kalshi_user: "SOLaddr", polymarket_user: "EVMaddr" })`.
+   * Legacy agg:    `getPositions("addr")` (same address for all providers).
    */
-  async getPositions(user, source) {
-    const query = buildQuery({ source, user });
+  async getPositions(userOrWallets, source) {
+    let query;
+    if (typeof userOrWallets === "string") {
+      query = buildQuery({ source, user: userOrWallets });
+    } else {
+      query = buildQuery(userOrWallets);
+    }
     const url = `${this.endpoint}/api/v1/positions${query}`;
     return await utils.httpGet(url);
   }
@@ -137,23 +143,46 @@ var PredictClient = class {
   // -------------------------------------------------------------------------
   // Orders
   // -------------------------------------------------------------------------
-  /** Maps to `GET /api/v1/orders?source=...&wallet_address=...`. */
-  async listOrders(params) {
+  /**
+   * Maps to `GET /api/v1/orders?source=...&wallet_address=...`.
+   *
+   * @param params  - Query parameters (source, wallet_address, etc.).
+   * @param headers - Optional extra headers (e.g. Polymarket POLY_* HMAC headers).
+   */
+  async listOrders(params, headers) {
     const query = buildQuery(params);
     const url = `${this.endpoint}/api/v1/orders${query}`;
-    return await utils.httpGet(url);
+    return await utils.httpGet(
+      url,
+      headers ? { headers } : void 0
+    );
   }
-  /** Maps to `GET /api/v1/orders/:id?source=...`. */
-  async getOrder(id, source) {
+  /**
+   * Maps to `GET /api/v1/orders/:id?source=...`.
+   *
+   * @param id      - Order ID.
+   * @param source  - Provider source.
+   * @param headers - Optional extra headers (e.g. Polymarket POLY_* HMAC headers).
+   */
+  async getOrder(id, source, headers) {
     const query = buildQuery({ source });
     const url = `${this.endpoint}/api/v1/orders/${encodeURIComponent(id)}${query}`;
-    return await utils.httpGet(url);
+    return await utils.httpGet(url, headers ? { headers } : void 0);
   }
-  /** Maps to `DELETE /api/v1/orders/:id?source=...`. */
-  async cancelOrder(id, source) {
+  /**
+   * Maps to `DELETE /api/v1/orders/:id?source=...`.
+   *
+   * @param id      - Order ID.
+   * @param source  - Provider source.
+   * @param headers - Optional extra headers (e.g. Polymarket POLY_* HMAC headers).
+   */
+  async cancelOrder(id, source, headers) {
     const query = buildQuery({ source });
     const url = `${this.endpoint}/api/v1/orders/${encodeURIComponent(id)}${query}`;
-    return await utils.httpDelete(url);
+    return await utils.httpDelete(
+      url,
+      headers ? { headers } : void 0
+    );
   }
   // -------------------------------------------------------------------------
   // Polymarket trading
@@ -203,6 +232,30 @@ var PredictClient = class {
     return await utils.httpGet(url);
   }
   // -------------------------------------------------------------------------
+  // Polymarket wallet setup
+  // -------------------------------------------------------------------------
+  /**
+   * Check Polymarket wallet setup status (Safe deployed + USDC.e approved).
+   *
+   * Maps to `GET /api/v1/setup/polymarket?wallet_address=...`.
+   */
+  async checkPolymarketSetup(walletAddress) {
+    const query = buildQuery({ wallet_address: walletAddress });
+    const url = `${this.endpoint}/api/v1/setup/polymarket${query}`;
+    return await utils.httpGet(url);
+  }
+  /**
+   * Run Polymarket wallet setup (deploy Safe + approve USDC.e).
+   *
+   * Maps to `POST /api/v1/setup/polymarket`.
+   */
+  async runPolymarketSetup(walletAddress) {
+    const url = `${this.endpoint}/api/v1/setup/polymarket`;
+    return await utils.httpPost(url, {
+      wallet_address: walletAddress
+    });
+  }
+  // -------------------------------------------------------------------------
   // Cross-platform matches
   // -------------------------------------------------------------------------
   /**
@@ -224,6 +277,16 @@ var PredictClient = class {
     const url = `${this.endpoint}/api/v1/matches/${id}`;
     return await utils.httpGet(url);
   }
+  /**
+   * List flattened market pairs across match groups (market-level granularity).
+   *
+   * Maps to `GET /api/v1/matches/markets`.
+   */
+  async listMatchMarkets(params) {
+    const query = buildQuery(params ?? {});
+    const url = `${this.endpoint}/api/v1/matches/markets${query}`;
+    return await utils.httpGet(url);
+  }
   // -------------------------------------------------------------------------
   // Trades by wallet
   // -------------------------------------------------------------------------
@@ -233,6 +296,73 @@ var PredictClient = class {
     const url = `${this.endpoint}/api/v1/trades${query}`;
     return await utils.httpGet(url);
   }
+  // -------------------------------------------------------------------------
+  // Withdraw
+  // -------------------------------------------------------------------------
+  /** Maps to `POST /api/v1/withdraw/build`. */
+  async withdrawBuild(body) {
+    const url = `${this.endpoint}/api/v1/withdraw/build`;
+    return await utils.httpPost(url, body);
+  }
+  /** Maps to `POST /api/v1/withdraw/submit`. */
+  async withdrawSubmit(body) {
+    const url = `${this.endpoint}/api/v1/withdraw/submit`;
+    return await utils.httpPost(url, body);
+  }
+  /** Maps to `GET /api/v1/withdraw/status?tx_hash=...&source=...`. */
+  async withdrawStatus(txHash, source) {
+    const query = buildQuery({ tx_hash: txHash, source });
+    const url = `${this.endpoint}/api/v1/withdraw/status${query}`;
+    return await utils.httpGet(url);
+  }
+  // -------------------------------------------------------------------------
+  // Deposit (native USDC → USDC.e for Polymarket)
+  // -------------------------------------------------------------------------
+  /**
+   * Build unsigned deposit transactions (approve + Uniswap V3 swap).
+   *
+   * The server checks the Safe's USDC.e balance and returns only
+   * the transactions needed to cover the shortfall.
+   *
+   * Maps to `POST /api/v1/deposit/polymarket/build`.
+   */
+  async depositBuild(body) {
+    const url = `${this.endpoint}/api/v1/deposit/polymarket/build`;
+    return await utils.httpPost(url, body);
+  }
+  /** Maps to `POST /api/v1/deposit/polymarket/submit`. */
+  async depositSubmit(body) {
+    const url = `${this.endpoint}/api/v1/deposit/polymarket/submit`;
+    return await utils.httpPost(url, body);
+  }
+  /** Maps to `GET /api/v1/deposit/polymarket/status?tx_hash=...&source=...`. */
+  async depositStatus(txHash, source) {
+    const query = buildQuery({ tx_hash: txHash, source });
+    const url = `${this.endpoint}/api/v1/deposit/polymarket/status${query}`;
+    return await utils.httpGet(url);
+  }
+  /**
+   * Get multi-chain deposit addresses for a Polymarket Safe wallet via Bridge API.
+   *
+   * Maps to `GET /api/v1/deposit/polymarket/addresses?safe_address=...`.
+   */
+  async getPolymarketDepositAddresses(safeAddress) {
+    const query = buildQuery({ safe_address: safeAddress });
+    const url = `${this.endpoint}/api/v1/deposit/polymarket/addresses${query}`;
+    return await utils.httpGet(url);
+  }
+  // -------------------------------------------------------------------------
+  // Polymarket Relayer Withdraw
+  // -------------------------------------------------------------------------
+  /**
+   * Execute a gasless USDC.e withdrawal from a Polymarket Safe wallet via Relayer.
+   *
+   * Maps to `POST /api/v1/withdraw/polymarket/execute`.
+   */
+  async executePolymarketWithdraw(body) {
+    const url = `${this.endpoint}/api/v1/withdraw/polymarket/execute`;
+    return await utils.httpPost(url, body);
+  }
 };
 function createPredictClient(endpoint) {
   return new PredictClient(endpoint);
@@ -587,7 +717,9 @@ function encode(str) {
   return new TextEncoder().encode(str);
 }
 function base64ToBytes(b64) {
-  const binary = atob(b64);
+  let std = b64.replace(/-/g, "+").replace(/_/g, "/");
+  while (std.length % 4 !== 0) std += "=";
+  const binary = atob(std);
   const bytes = new Uint8Array(binary.length);
   for (let i = 0; i < binary.length; i++) {
     bytes[i] = binary.charCodeAt(i);
@@ -616,7 +748,8 @@ async function hmacSha256Base64(secretBase64, message) {
     cryptoKey,
     msgBytes.buffer
   );
-  return bytesToBase64(new Uint8Array(signature));
+  const b64 = bytesToBase64(new Uint8Array(signature));
+  return b64.replace(/\+/g, "-").replace(/\//g, "_");
 }
 async function buildPolymarketL2Headers(address, input) {
   const timestamp = Math.floor(Date.now() / 1e3).toString();
@@ -652,27 +785,34 @@ function buildClobAuthMessage(input) {
     message: "This message attests that I control the given wallet"
   };
 }
+function buildL1Headers(address, signature, timestamp, nonce) {
+  return {
+    POLY_ADDRESS: address,
+    POLY_SIGNATURE: signature,
+    POLY_TIMESTAMP: timestamp,
+    POLY_NONCE: String(nonce)
+  };
+}
 async function derivePolymarketApiKey(address, signature, timestamp, nonce) {
-  const res = await fetch(
+  const headers = buildL1Headers(address, signature, timestamp, nonce);
+  const deriveRes = await fetch(
     `https://clob.polymarket.com/auth/derive-api-key?nonce=${nonce}`,
-    {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json",
-        POLY_ADDRESS: address,
-        POLY_SIGNATURE: signature,
-        POLY_TIMESTAMP: timestamp,
-        POLY_NONCE: String(nonce)
-      }
-    }
+    { method: "GET", headers }
   );
-  if (!res.ok) {
-    const text = await res.text().catch(() => res.statusText);
-    throw new Error(
-      `Polymarket credential exchange failed (${res.status}): ${text}`
-    );
+  if (deriveRes.ok) {
+    return deriveRes.json();
   }
-  return res.json();
+  const createRes = await fetch("https://clob.polymarket.com/auth/api-key", {
+    method: "POST",
+    headers
+  });
+  if (createRes.ok) {
+    return createRes.json();
+  }
+  const text = await createRes.text().catch(() => createRes.statusText);
+  throw new Error(
+    `Polymarket credential exchange failed (${createRes.status}): ${text}`
+  );
 }
 var PolymarketContext = react.createContext(
   null
@@ -687,7 +827,7 @@ function PolymarketProvider({ children }) {
   const authenticate = react.useCallback(
     async (signer) => {
       if (lastAuthAddressRef.current === signer.address && credentials !== null) {
-        return;
+        return credentials;
       }
       setIsAuthenticating(true);
       setAuthError(null);
@@ -702,6 +842,7 @@ function PolymarketProvider({ children }) {
         const signature = await signer.signTypedData(
           CLOB_AUTH_DOMAIN,
           CLOB_AUTH_TYPES,
+          "ClobAuth",
           message
         );
         const { apiKey, secret, passphrase } = await derivePolymarketApiKey(
@@ -710,13 +851,21 @@ function PolymarketProvider({ children }) {
           timestamp,
           nonce
         );
+        const newCreds = {
+          apiKey,
+          secret,
+          passphrase,
+          address: signer.address
+        };
         lastAuthAddressRef.current = signer.address;
-        setCredentials({ apiKey, secret, passphrase, address: signer.address });
+        setCredentials(newCreds);
+        return newCreds;
       } catch (err) {
         setAuthError(
           err instanceof Error ? err : new Error("Polymarket authentication failed")
         );
         lastAuthAddressRef.current = null;
+        throw err;
       } finally {
         setIsAuthenticating(false);
       }
@@ -1028,6 +1177,15 @@ function useCandlesticks(params, queryOptions = {}) {
 function positionsQueryKey(user, source) {
   return ["predict", "positions", source ?? "all", user];
 }
+function positionsMultiQueryKey(wallets) {
+  return [
+    "predict",
+    "positions",
+    "multi",
+    wallets.kalshi_user ?? "",
+    wallets.polymarket_user ?? ""
+  ];
+}
 function usePositions(params, queryOptions = {}) {
   const client = usePredictClient();
   return reactQuery.useQuery({
@@ -1038,6 +1196,17 @@ function usePositions(params, queryOptions = {}) {
     ...queryOptions
   });
 }
+function usePositionsMulti(params, queryOptions = {}) {
+  const client = usePredictClient();
+  const hasAnyWallet = Boolean(params.kalshi_user || params.polymarket_user);
+  return reactQuery.useQuery({
+    queryKey: positionsMultiQueryKey(params),
+    queryFn: () => client.getPositions(params),
+    enabled: hasAnyWallet,
+    staleTime: 1e4,
+    ...queryOptions
+  });
+}
 function balanceQueryKey(source, user) {
   return ["predict", "balance", source, user];
 }
@@ -1054,11 +1223,14 @@ function useBalance(params, queryOptions = {}) {
 function ordersQueryKey(params) {
   return ["predict", "orders", params];
 }
-function useOrders(params, queryOptions = {}) {
+function useOrders(params, options, queryOptions = {}) {
   const client = usePredictClient();
   return reactQuery.useQuery({
     queryKey: ordersQueryKey(params),
-    queryFn: () => client.listOrders(params),
+    queryFn: async () => {
+      const headers = await options?.getHeaders?.();
+      return client.listOrders(params, headers);
+    },
     enabled: Boolean(params.wallet_address),
     ...queryOptions
   });
@@ -1066,11 +1238,14 @@ function useOrders(params, queryOptions = {}) {
 function infiniteOrdersQueryKey(params) {
   return ["predict", "orders", "infinite", params];
 }
-function useInfiniteOrders(params) {
+function useInfiniteOrders(params, options) {
   const client = usePredictClient();
   return reactQuery.useInfiniteQuery({
     queryKey: infiniteOrdersQueryKey(params),
-    queryFn: ({ pageParam }) => client.listOrders({ ...params, next_cursor: pageParam }),
+    queryFn: async ({ pageParam }) => {
+      const headers = await options?.getHeaders?.();
+      return client.listOrders({ ...params, next_cursor: pageParam }, headers);
+    },
     initialPageParam: void 0,
     getNextPageParam: (lastPage) => lastPage.has_more ? lastPage.next_cursor : void 0,
     enabled: Boolean(params.wallet_address)
@@ -1136,6 +1311,34 @@ function useMatch(id, queryOptions = {}) {
     ...queryOptions
   });
 }
+
+// src/hooks/predict/matchMarkets.params.ts
+function matchMarketsQueryKey(params) {
+  return ["predict", "matchMarkets", params];
+}
+async function fetchMatchMarketsPage(client, params) {
+  return client.listMatchMarkets(params);
+}
+
+// src/hooks/predict/useMatchMarkets.ts
+function useInfiniteMatchMarkets(params, queryOptions = {}) {
+  const client = usePredictClient();
+  const limit = params.limit ?? 20;
+  return reactQuery.useInfiniteQuery({
+    queryKey: matchMarketsQueryKey(params),
+    queryFn: ({ pageParam }) => fetchMatchMarketsPage(client, {
+      ...params,
+      limit,
+      offset: pageParam
+    }),
+    initialPageParam: 0,
+    getNextPageParam: (lastPage) => {
+      const nextOffset = lastPage.offset + lastPage.items.length;
+      return nextOffset < lastPage.total ? nextOffset : void 0;
+    },
+    ...queryOptions
+  });
+}
 function tradesQueryKey(params) {
   return ["predict", "trades-by-wallet", params];
 }
@@ -1200,6 +1403,149 @@ function useDFlowKYC(walletAddress, queryOptions = {}) {
     ...queryOptions
   });
 }
+function polymarketSetupQueryKey(walletAddress) {
+  return ["predict", "setup", "polymarket", walletAddress];
+}
+function usePolymarketSetup(walletAddress, queryOptions = {}) {
+  const client = usePredictClient();
+  return reactQuery.useQuery({
+    queryKey: polymarketSetupQueryKey(walletAddress ?? ""),
+    queryFn: () => client.checkPolymarketSetup(walletAddress),
+    enabled: !!walletAddress,
+    staleTime: 6e4,
+    ...queryOptions
+  });
+}
+function useRunPolymarketSetup(walletAddress) {
+  const client = usePredictClient();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (address) => client.runPolymarketSetup(address),
+    onSuccess: () => {
+      if (walletAddress) {
+        queryClient.invalidateQueries({
+          queryKey: polymarketSetupQueryKey(walletAddress)
+        });
+      }
+    }
+  });
+}
+function useWithdrawBuildMutation(mutationOptions = {}) {
+  const client = usePredictClient();
+  return reactQuery.useMutation({
+    mutationFn: (body) => client.withdrawBuild(body),
+    ...mutationOptions
+  });
+}
+function useWithdrawSubmitMutation(mutationOptions = {}) {
+  const client = usePredictClient();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (body) => client.withdrawSubmit(body),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["predict", "balance"] });
+      queryClient.invalidateQueries({ queryKey: ["predict", "positions"] });
+    },
+    ...mutationOptions
+  });
+}
+function withdrawStatusQueryKey(txHash, source) {
+  return ["predict", "withdraw", "status", txHash, source];
+}
+function useWithdrawStatusQuery(params, queryOptions = {}) {
+  const client = usePredictClient();
+  const { txHash, source } = params;
+  return reactQuery.useQuery({
+    queryKey: withdrawStatusQueryKey(txHash ?? "", source),
+    queryFn: () => client.withdrawStatus(txHash, source),
+    enabled: Boolean(txHash && source),
+    refetchInterval: (query) => {
+      const status = query.state.data?.status;
+      if (status === "confirmed" || status === "failed") return false;
+      return 3e3;
+    },
+    ...queryOptions
+  });
+}
+var TX_POLL_INTERVAL = 3e3;
+var TX_POLL_MAX_ATTEMPTS = 60;
+function usePolymarketDeposit(mutationOptions = {}) {
+  const client = usePredictClient();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async ({
+      from,
+      safeAddress,
+      amount,
+      signTransaction
+    }) => {
+      const buildResult = await client.depositBuild({
+        source: "polymarket",
+        from,
+        safe_address: safeAddress,
+        amount
+      });
+      if (buildResult.transactions.length === 0) {
+        return {
+          deposited: false,
+          txCount: 0,
+          shortfall: buildResult.shortfall,
+          safeBalance: buildResult.safe_balance
+        };
+      }
+      for (const unsignedTx of buildResult.transactions) {
+        const signedHex = await signTransaction(unsignedTx.params);
+        const submitResult = await client.depositSubmit({
+          source: "polymarket",
+          signed_tx: signedHex
+        });
+        await pollTxUntilConfirmed(client, submitResult.tx_hash);
+      }
+      return {
+        deposited: true,
+        txCount: buildResult.transactions.length,
+        shortfall: buildResult.shortfall,
+        safeBalance: buildResult.safe_balance
+      };
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["predict", "balance"] });
+    },
+    ...mutationOptions
+  });
+}
+async function pollTxUntilConfirmed(client, txHash) {
+  for (let i = 0; i < TX_POLL_MAX_ATTEMPTS; i++) {
+    await sleep(TX_POLL_INTERVAL);
+    const result = await client.depositStatus(txHash, "polymarket");
+    if (result.status === "confirmed") return;
+    if (result.status === "failed") {
+      throw new Error(`Deposit transaction failed: ${txHash}`);
+    }
+  }
+  throw new Error(
+    `Deposit transaction timed out after ${TX_POLL_MAX_ATTEMPTS * TX_POLL_INTERVAL / 1e3}s: ${txHash}`
+  );
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var polymarketDepositAddressesQueryKey = (safeAddress) => ["polymarket", "deposit-addresses", safeAddress];
+function usePolymarketDepositAddresses(safeAddress) {
+  const client = usePredictClient();
+  return reactQuery.useQuery({
+    queryKey: polymarketDepositAddressesQueryKey(safeAddress ?? ""),
+    queryFn: () => client.getPolymarketDepositAddresses(safeAddress),
+    enabled: !!safeAddress,
+    staleTime: 5 * 60 * 1e3
+  });
+}
+function usePolymarketWithdraw() {
+  const client = usePredictClient();
+  return reactQuery.useMutation({
+    mutationFn: (req) => client.executePolymarketWithdraw(req)
+  });
+}
 function usePredictWsClient() {
   const context = react.useContext(PredictContext);
   if (!context) {
@@ -1448,7 +1794,7 @@ var USDC_ADDRESS = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
 var POLYGON_CHAIN_ID = 137;
 function buildCtfExchangeDomain(negRisk = false) {
   return {
-    name: "CTFExchange",
+    name: "Polymarket CTF Exchange",
     version: "1",
     chainId: POLYGON_CHAIN_ID,
     verifyingContract: negRisk ? NEG_RISK_CTF_EXCHANGE_ADDRESS : CTF_EXCHANGE_ADDRESS
@@ -1494,6 +1840,12 @@ function roundToTick(price, tickSize) {
 function toMicroUsdc(amount) {
   return BigInt(Math.round(amount * 1e6));
 }
+function normalizeTokenId(tokenId) {
+  if (tokenId.startsWith("0x") || tokenId.startsWith("0X")) {
+    return BigInt(tokenId).toString(10);
+  }
+  return tokenId;
+}
 function buildOrderMessage(input) {
   const side = input.side === "BUY" ? SIDE.BUY : SIDE.SELL;
   const priceStr = roundToTick(input.price, input.tickSize);
@@ -1508,7 +1860,7 @@ function buildOrderMessage(input) {
     maker,
     signer: input.signerAddress,
     taker: "0x0000000000000000000000000000000000000000",
-    tokenId: input.tokenId,
+    tokenId: normalizeTokenId(input.tokenId),
     makerAmount,
     takerAmount,
     expiration: String(input.expiration ?? 0),
@@ -1518,16 +1870,30 @@ function buildOrderMessage(input) {
     signatureType: input.signatureType
   };
 }
-function buildSignedOrder(input) {
-  const message = buildOrderMessage(input);
+function buildSignedOrder(orderMessage, signature, orderType) {
   return {
-    ...message,
-    signature: input.signature,
-    orderType: input.orderType ?? "GTC"
+    ...orderMessage,
+    signature,
+    orderType: orderType ?? "GTC"
+  };
+}
+function buildClobPayload(signedOrder, owner) {
+  const { orderType: ot, ...order } = signedOrder;
+  return {
+    order: {
+      ...order,
+      salt: parseInt(order.salt, 10),
+      side: order.side === SIDE.BUY ? "BUY" : "SELL"
+    },
+    owner,
+    orderType: ot ?? "GTC",
+    deferExec: false
   };
 }
 
 // src/hooks/polymarket/useCreatePolymarketOrder.ts
+var TX_POLL_INTERVAL2 = 3e3;
+var TX_POLL_MAX_ATTEMPTS2 = 60;
 function useCreatePolymarketOrder(mutationOptions = {}) {
   const client = usePredictClient();
   const { credentials, authenticate } = usePolymarket();
@@ -1537,13 +1903,27 @@ function useCreatePolymarketOrder(mutationOptions = {}) {
       input,
       signer
     }) => {
-      const creds = credentials;
-      if (!creds) {
-        await authenticate(signer);
-        if (!creds) {
-          throw new Error(
-            "Polymarket authentication failed. Cannot create order without credentials."
-          );
+      const creds = credentials ?? await authenticate(signer);
+      if (signer.signTransaction && input.funderAddress) {
+        const orderCost = computeOrderCost(input);
+        const buildResult = await client.depositBuild({
+          source: "polymarket",
+          from: signer.address,
+          safe_address: input.funderAddress,
+          amount: orderCost
+        });
+        if (buildResult.transactions.length > 0) {
+          for (const unsignedTx of buildResult.transactions) {
+            const signedHex = await signer.signTransaction(unsignedTx.params);
+            const submitResult = await client.depositSubmit({
+              source: "polymarket",
+              signed_tx: signedHex
+            });
+            await pollTxConfirmed(
+              (txHash) => client.depositStatus(txHash, "polymarket"),
+              submitResult.tx_hash
+            );
+          }
         }
       }
       const domain = buildCtfExchangeDomain(input.negRisk ?? false);
@@ -1555,35 +1935,54 @@ function useCreatePolymarketOrder(mutationOptions = {}) {
       const signature = await signer.signTypedData(
         domain,
         CTF_ORDER_TYPES,
+        "Order",
         orderMessage
       );
-      const signedOrder = buildSignedOrder({
-        ...input,
-        signerAddress: signer.address,
-        signatureType: signer.signatureType,
-        signature
-      });
-      const body = JSON.stringify(signedOrder);
+      const signedOrder = buildSignedOrder(
+        orderMessage,
+        signature,
+        input.orderType
+      );
+      const clobPayload = buildClobPayload(signedOrder, creds.apiKey);
+      const body = JSON.stringify(clobPayload);
       const headers = await buildPolymarketL2Headers(creds.address, {
         apiKey: creds.apiKey,
         secret: creds.secret,
         passphrase: creds.passphrase,
         method: "POST",
-        requestPath: "/api/v1/orders/polymarket",
+        requestPath: "/order",
         body
       });
       return client.createPolymarketOrder(
-        signedOrder,
+        clobPayload,
         headers
       );
     },
     onSuccess: () => {
       queryClient.invalidateQueries({ queryKey: ["predict", "orders"] });
       queryClient.invalidateQueries({ queryKey: ["predict", "positions"] });
+      queryClient.invalidateQueries({ queryKey: ["predict", "balance"] });
     },
     ...mutationOptions
   });
 }
+function computeOrderCost(input) {
+  if (input.side === "SELL") return "0";
+  return (input.price * input.size).toFixed(6);
+}
+async function pollTxConfirmed(fetchStatus, txHash) {
+  for (let i = 0; i < TX_POLL_MAX_ATTEMPTS2; i++) {
+    await new Promise((r) => setTimeout(r, TX_POLL_INTERVAL2));
+    const result = await fetchStatus(txHash);
+    if (result.status === "confirmed") return;
+    if (result.status === "failed") {
+      throw new Error(`Deposit transaction failed: ${txHash}`);
+    }
+  }
+  throw new Error(
+    `Deposit transaction timed out after ${TX_POLL_MAX_ATTEMPTS2 * TX_POLL_INTERVAL2 / 1e3}s: ${txHash}`
+  );
+}
 
 exports.CLOB_AUTH_DOMAIN = CLOB_AUTH_DOMAIN;
 exports.CLOB_AUTH_TYPES = CLOB_AUTH_TYPES;
@@ -1603,6 +2002,7 @@ exports.SIDE = SIDE;
 exports.USDC_ADDRESS = USDC_ADDRESS;
 exports.balanceQueryKey = balanceQueryKey;
 exports.buildClobAuthMessage = buildClobAuthMessage;
+exports.buildClobPayload = buildClobPayload;
 exports.buildCtfExchangeDomain = buildCtfExchangeDomain;
 exports.buildOrderMessage = buildOrderMessage;
 exports.buildPolymarketL2Headers = buildPolymarketL2Headers;
@@ -1619,6 +2019,7 @@ exports.fetchEvent = fetchEvent;
 exports.fetchEvents = fetchEvents;
 exports.fetchEventsPage = fetchEventsPage;
 exports.fetchMarket = fetchMarket;
+exports.fetchMatchMarketsPage = fetchMatchMarketsPage;
 exports.fetchMatchesPage = fetchMatchesPage;
 exports.hmacSha256Base64 = hmacSha256Base64;
 exports.infiniteEventsQueryKey = infiniteEventsQueryKey;
@@ -1626,11 +2027,15 @@ exports.infiniteOrdersQueryKey = infiniteOrdersQueryKey;
 exports.infiniteTradesQueryKey = infiniteTradesQueryKey;
 exports.marketQueryKey = marketQueryKey;
 exports.marketTradesQueryKey = marketTradesQueryKey;
+exports.matchMarketsQueryKey = matchMarketsQueryKey;
 exports.matchQueryKey = matchQueryKey;
 exports.matchesQueryKey = matchesQueryKey;
 exports.orderQueryKey = orderQueryKey;
 exports.orderbookQueryKey = orderbookQueryKey;
 exports.ordersQueryKey = ordersQueryKey;
+exports.polymarketDepositAddressesQueryKey = polymarketDepositAddressesQueryKey;
+exports.polymarketSetupQueryKey = polymarketSetupQueryKey;
+exports.positionsMultiQueryKey = positionsMultiQueryKey;
 exports.positionsQueryKey = positionsQueryKey;
 exports.priceHistoryQueryKey = priceHistoryQueryKey;
 exports.resolveEventsParams = resolveEventsParams;
@@ -1647,6 +2052,7 @@ exports.useDFlowSubmit = useDFlowSubmit;
 exports.useEvent = useEvent;
 exports.useEvents = useEvents;
 exports.useInfiniteEvents = useInfiniteEvents;
+exports.useInfiniteMatchMarkets = useInfiniteMatchMarkets;
 exports.useInfiniteMatches = useInfiniteMatches;
 exports.useInfiniteOrders = useInfiniteOrders;
 exports.useInfiniteTrades = useInfiniteTrades;
@@ -1659,7 +2065,12 @@ exports.useOrderbook = useOrderbook;
 exports.useOrderbookSubscription = useOrderbookSubscription;
 exports.useOrders = useOrders;
 exports.usePolymarket = usePolymarket;
+exports.usePolymarketDeposit = usePolymarketDeposit;
+exports.usePolymarketDepositAddresses = usePolymarketDepositAddresses;
+exports.usePolymarketSetup = usePolymarketSetup;
+exports.usePolymarketWithdraw = usePolymarketWithdraw;
 exports.usePositions = usePositions;
+exports.usePositionsMulti = usePositionsMulti;
 exports.usePredictClient = usePredictClient;
 exports.usePredictWsClient = usePredictWsClient;
 exports.usePriceHistory = usePriceHistory;
@@ -1667,9 +2078,14 @@ exports.usePricesSubscription = usePricesSubscription;
 exports.useRealtimeOrderbook = useRealtimeOrderbook;
 exports.useRealtimePrices = useRealtimePrices;
 exports.useRealtimeTrades = useRealtimeTrades;
+exports.useRunPolymarketSetup = useRunPolymarketSetup;
 exports.useSearchEvents = useSearchEvents;
 exports.useSimilarEvents = useSimilarEvents;
 exports.useTrades = useTrades;
 exports.useTradesSubscription = useTradesSubscription;
+exports.useWithdrawBuildMutation = useWithdrawBuildMutation;
+exports.useWithdrawStatusQuery = useWithdrawStatusQuery;
+exports.useWithdrawSubmitMutation = useWithdrawSubmitMutation;
+exports.withdrawStatusQueryKey = withdrawStatusQueryKey;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map