SDK 迁移 - Polymarket Documentation

从旧版 CLOB、Relayer 和 Builder 签名客户端迁移到统一 SDK。

TypeScript
Python
Rust

下面的示例将之前的客户端功能映射到 @polymarket/client。该 SDK 还涵盖了 Gamma API 和 Data API。直接迁移 Gamma 和 Data 调用可以简化应用程序代码，并提供与 SDK 的交易和工作流无缝配合的标准化、类型化的模型。

安装统一 SDK

移除集成中使用的旧版 CLOB、Relayer 和 Builder 签名包。然后安装统一 SDK 和你的钱包库。

npm uninstall @polymarket/clob-client-v2 @polymarket/builder-relayer-client @polymarket/builder-signing-sdk
npm install @polymarket/client@latest viem

pnpm remove @polymarket/clob-client-v2 @polymarket/builder-relayer-client @polymarket/builder-signing-sdk
pnpm add @polymarket/client@latest viem

yarn remove @polymarket/clob-client-v2 @polymarket/builder-relayer-client @polymarket/builder-signing-sdk
yarn add @polymarket/client@latest viem

bun remove @polymarket/clob-client-v2 @polymarket/builder-relayer-client @polymarket/builder-signing-sdk
bun add @polymarket/client@latest viem

统一 SDK 包含了针对 Viem、Privy 和 Ethers v5 的签名器适配器，因此你可以连接自己的钱包库而无需实现 CLOB 特定的签名逻辑。请参阅钱包集成获取设置示例。

客户端和钱包设置

创建公共客户端

PublicClient 提供无需身份验证的市场发现和数据读取功能。 createPublicClient 默认使用生产环境，且不需要主机或链 ID。

Before

import { ClobClient } from "@polymarket/clob-client-v2";

const client = new ClobClient({
  host: "https://clob.polymarket.com",
  chain: 137,
});

After

import { createPublicClient } from "@polymarket/client";

const client = createPublicClient();

创建经过身份验证的客户端

SecureClient 增加了经过身份验证的交易、账户和钱包操作。 createSecureClient 派生或创建 CLOB 凭据，解析账户钱包，并配置正确的签名流程。

Before

import { ClobClient, SignatureTypeV2 } from "@polymarket/clob-client-v2";

const tempClient = new ClobClient({
  host: "https://clob.polymarket.com",
  chain: 137,
  signer,
});
const credentials = await tempClient.createOrDeriveApiKey();

const client = new ClobClient({
  host: "https://clob.polymarket.com",
  chain: 137,
  signer,
  creds: credentials,
  signatureType: SignatureTypeV2.POLY_1271,
  funderAddress: process.env.POLYMARKET_WALLET_ADDRESS,
});

After

import { type ApiKeyCreds, createSecureClient } from "@polymarket/client";
import { privateKey } from "@polymarket/client/viem";

const client = await createSecureClient({
  wallet: process.env.POLYMARKET_WALLET_ADDRESS,
  signer: privateKey(process.env.POLYMARKET_PRIVATE_KEY),
});

省略 wallet 以使用默认的 Deposit Wallet 流程。

使用现有凭据恢复

从已认证的客户端读取凭据，安全存储它们，并将其传递给新客户端以使用相同的 API 密钥恢复。签名者和钱包必须标识拥有这些凭据的账户。

Before

import { ClobClient, SignatureTypeV2 } from "@polymarket/clob-client-v2";

const credentials = client.creds;
if (!credentials) throw new Error("Client has no credentials");

// Store the credentials securely.

const resumedClient = new ClobClient({
  host: "https://clob.polymarket.com",
  chain: 137,
  signer,
  creds: credentials,
  signatureType: SignatureTypeV2.POLY_1271,
  funderAddress: process.env.POLYMARKET_WALLET_ADDRESS,
});

After

import { createSecureClient } from "@polymarket/client";
import { privateKey } from "@polymarket/client/viem";

const credentials = client.credentials;

// Store the credentials securely.

const resumedClient = await createSecureClient({
  wallet: process.env.POLYMARKET_WALLET_ADDRESS,
  signer: privateKey(process.env.POLYMARKET_PRIVATE_KEY),
  // Restore the type if loading from storage erased it.
  credentials: credentials as ApiKeyCreds,
});

撤销当前 API 密钥

结束认证将撤销当前的 API 密钥，使 SecureClient 失效，并返回一个 PublicClient。

Before

await client.deleteApiKey();

After

const publicClient = await client.endAuthentication();

配置 Builder API 密钥

SecureClient 接受用于无 Gas 钱包操作的 Builder 授权。将本地或远程的 Builder 签名迁移到相应的辅助函数。本地 Builder API 密钥在服务器上保留本地 Builder 凭据。Node.js 入口点会生成所需的 HMAC 请求头。

Before

import { RelayClient } from "@polymarket/builder-relayer-client";
import { BuilderConfig } from "@polymarket/builder-signing-sdk";

const builderConfig = new BuilderConfig({
  localBuilderCreds: {
    key: process.env.POLYMARKET_BUILDER_API_KEY!,
    secret: process.env.POLYMARKET_BUILDER_SECRET!,
    passphrase: process.env.POLYMARKET_BUILDER_PASSPHRASE!,
  },
});

const relayer = new RelayClient(
  "https://relayer-v2.polymarket.com",
  137,
  walletClient,
  builderConfig,
);

After

import { createSecureClient } from "@polymarket/client";
import { builderApiKey } from "@polymarket/client/node";
import { privateKey } from "@polymarket/client/viem";

const client = await createSecureClient({
  signer: privateKey(process.env.POLYMARKET_PRIVATE_KEY),
  apiKey: builderApiKey({
    key: process.env.POLYMARKET_BUILDER_API_KEY!,
    secret: process.env.POLYMARKET_BUILDER_SECRET!,
    passphrase: process.env.POLYMARKET_BUILDER_PASSPHRASE!,
  }),
});

远程 Builder 签名将 Builder 凭据保留在签名端点之后。客户端发送相同的 { method, path, body } 请求并应用相同的 Builder 请求头，因此端点契约无需更改。

Before

import { RelayClient } from "@polymarket/builder-relayer-client";
import { BuilderConfig } from "@polymarket/builder-signing-sdk";

const builderConfig = new BuilderConfig({
  remoteBuilderConfig: {
    url: "https://example.com/api/builder/sign",
    token: process.env.BUILDER_SIGNING_TOKEN,
  },
});

const relayer = new RelayClient(
  "https://relayer-v2.polymarket.com",
  137,
  walletClient,
  builderConfig,
);

After

import { createSecureClient, remoteBuilderSigning } from "@polymarket/client";

const client = await createSecureClient({
  signer,
  apiKey: remoteBuilderSigning({
    url: "https://example.com/api/builder/sign",
    headers: {
      Authorization: `Bearer ${process.env.BUILDER_SIGNING_TOKEN}`,
    },
  }),
});

在签名服务器上，将 BuilderConfig.generateBuilderHeaders 替换为 buildHmacSignature。保留你现有的调用者认证和针对此处理程序的授权。

Before

import { BuilderConfig } from "@polymarket/builder-signing-sdk";

const builderConfig = new BuilderConfig({
  localBuilderCreds: {
    key: process.env.POLYMARKET_BUILDER_API_KEY!,
    secret: process.env.POLYMARKET_BUILDER_SECRET!,
    passphrase: process.env.POLYMARKET_BUILDER_PASSPHRASE!,
  },
});

export async function POST(request: Request): Promise<Response> {
  const { body, method, path } = await request.json();
  const headers = await builderConfig.generateBuilderHeaders(
    method,
    path,
    body,
  );

  return Response.json(headers);
}

After

import { buildHmacSignature } from "@polymarket/client";

export async function POST(request: Request): Promise<Response> {
  const { body, method, path } = await request.json();
  const timestamp = Math.floor(Date.now() / 1000);

  return Response.json({
    POLY_BUILDER_API_KEY: process.env.POLYMARKET_BUILDER_API_KEY!,
    POLY_BUILDER_PASSPHRASE: process.env.POLYMARKET_BUILDER_PASSPHRASE!,
    POLY_BUILDER_SIGNATURE: await buildHmacSignature(
      process.env.POLYMARKET_BUILDER_SECRET!,
      timestamp,
      method,
      path,
      body,
    ),
    POLY_BUILDER_TIMESTAMP: `${timestamp}`,
  });
}

配置 Relayer API 密钥

SecureClient 直接配置 Relayer API 密钥。在重新连接现有账户时，将密钥及其关联地址传递给 relayerApiKey。

import { createSecureClient, relayerApiKey } from "@polymarket/client";
import { privateKey } from "@polymarket/client/viem";

const client = await createSecureClient({
  wallet: process.env.POLYMARKET_WALLET_ADDRESS,
  signer: privateKey(process.env.POLYMARKET_PRIVATE_KEY),
  apiKey: relayerApiKey({
    key: process.env.POLYMARKET_RELAYER_API_KEY!,
    address: process.env.POLYMARKET_RELAYER_API_KEY_ADDRESS!,
  }),
});

部署 Deposit Wallet

在不提供 wallet 的情况下创建 SecureClient 会派生签名者的 Deposit Wallet 地址，并在需要时进行部署。使用上述 Builder 授权策略之一来授权部署。

Before

const deployment = await relayer.deployDepositWallet();
await deployment.wait();

After

import { createSecureClient } from "@polymarket/client";
import { builderApiKey } from "@polymarket/client/node";
import { privateKey } from "@polymarket/client/viem";

const client = await createSecureClient({
  signer: privateKey(process.env.POLYMARKET_PRIVATE_KEY),
  apiKey: builderApiKey({
    key: process.env.POLYMARKET_BUILDER_API_KEY!,
    secret: process.env.POLYMARKET_BUILDER_SECRET!,
    passphrase: process.env.POLYMARKET_BUILDER_PASSPHRASE!,
  }),
});

const depositWalletAddress = client.account.wallet;

市场发现

获取市场

PublicClient 和 SecureClient 均提供 fetchMarket，用于通过 Gamma 市场 ID、slug 或 Polymarket URL 进行读取。

Before

const market = await client.getMarket("CONDITION_ID");

After

const market = await client.fetchMarket({ slug: "MARKET_SLUG" });

如果你只有条件 ID，请筛选 listMarkets 并获取其第一页。

const page = await client
  .listMarkets({ conditionIds: ["CONDITION_ID"] })
  .firstPage();

const market = page.items[0];

列出市场

PublicClient 和 SecureClient 均提供 listMarkets，它返回一个分页器并直接接受筛选条件。

Before

const page = await client.getMarkets();
const markets = page.data;

After

const pages = client.listMarkets({ closed: false, pageSize: 20 });
const page = await pages.firstPage();
const markets = page.items;

getSimplifiedMarkets 不需要单独的替代方案。统一的市场模型已针对 SDK 使用进行了规范化。采样市场读取应迁移至 listCurrentRewards，后者列出当前的奖励配置。

Before

const markets = await client.getSamplingMarkets();
const page = await client.getSamplingSimplifiedMarkets();

After

const pages = client.listCurrentRewards();
const page = await pages.firstPage();

市场数据

读取交易参数

PublicClient 和 SecureClient 均返回统一市场模型中的 tick size 和负风险状态。下单方法也会自动解析这些值，因此你在下单时无需再传递这两个值。

Before

const tickSize = await client.getTickSize("TOKEN_ID");
const negRisk = await client.getNegRisk("TOKEN_ID");

After

const page = await client
  .listMarkets({ clobTokenIds: ["TOKEN_ID"] })
  .firstPage();

const market = page.items[0];
const tickSize = market?.trading.minimumTickSize;
const negRisk = market?.state.negRisk;

读取 CLOB 市场详情

PublicClient 和 SecureClient 均返回用于公开产品数据的标准化市场模型。其交易字段取代了紧凑的 CLOB 市场响应和独立的费用读取。

Before

const info = await client.getClobMarketInfo("CONDITION_ID");
const feeRateBps = await client.getFeeRateBps("TOKEN_ID");
const feeExponent = await client.getFeeExponent("TOKEN_ID");

After

const page = await client
  .listMarkets({ conditionIds: ["CONDITION_ID"] })
  .firstPage();

const market = page.items[0];
const feeSchedule = market?.trading.feeSchedule;

获取订单簿

PublicClient 和 SecureClient 提供带有 camelCase 请求字段的单个和批量订单簿读取功能。

Before

const book = await client.getOrderBook("TOKEN_ID");
const books = await client.getOrderBooks([
  { token_id: "TOKEN_ID_1" },
  { token_id: "TOKEN_ID_2" },
]);

After

const book = await client.fetchOrderBook({ tokenId: "TOKEN_ID" });
const books = await client.fetchOrderBooks([
  { tokenId: "TOKEN_ID_1" },
  { tokenId: "TOKEN_ID_2" },
]);

获取价格

PublicClient 和 SecureClient 提供带有 OrderSide 和 camelCase 请求字段的单个和批量价格读取功能。

Before

import { Side } from "@polymarket/clob-client-v2";

const price = await client.getPrice("TOKEN_ID", Side.BUY);
const prices = await client.getPrices([
  { token_id: "TOKEN_ID_1", side: Side.BUY },
  { token_id: "TOKEN_ID_2", side: Side.SELL },
]);

After

import { OrderSide } from "@polymarket/client";

const price = await client.fetchPrice({
  tokenId: "TOKEN_ID",
  side: OrderSide.BUY,
});
const prices = await client.fetchPrices([
  { tokenId: "TOKEN_ID_1", side: OrderSide.BUY },
  { tokenId: "TOKEN_ID_2", side: OrderSide.SELL },
]);

获取中间价

PublicClient 和 SecureClient 提供用于单个和批量读取的 fetchMidpoint 和 fetchMidpoints。

Before

const midpoint = await client.getMidpoint("TOKEN_ID");
const midpoints = await client.getMidpoints([
  { token_id: "TOKEN_ID_1" },
  { token_id: "TOKEN_ID_2" },
]);

After

const midpoint = await client.fetchMidpoint({ tokenId: "TOKEN_ID" });
const midpoints = await client.fetchMidpoints([
  { tokenId: "TOKEN_ID_1" },
  { tokenId: "TOKEN_ID_2" },
]);

获取价差

PublicClient 和 SecureClient 提供具有相同请求模式的单个和批量价差读取功能。

Before

const spread = await client.getSpread("TOKEN_ID");
const spreads = await client.getSpreads([
  { token_id: "TOKEN_ID_1" },
  { token_id: "TOKEN_ID_2" },
]);

After

const spread = await client.fetchSpread({ tokenId: "TOKEN_ID" });
const spreads = await client.fetchSpreads([
  { tokenId: "TOKEN_ID_1" },
  { tokenId: "TOKEN_ID_2" },
]);

获取最新成交价

PublicClient 和 SecureClient 均提供用于获取最新成交价的单条和批量方法。

Before

const lastTrade = await client.getLastTradePrice("TOKEN_ID");
const lastTrades = await client.getLastTradesPrices([
  { token_id: "TOKEN_ID_1" },
  { token_id: "TOKEN_ID_2" },
]);

After

const lastTrade = await client.fetchLastTradePrice({ tokenId: "TOKEN_ID" });
const lastTrades = await client.fetchLastTradePrices([
  { tokenId: "TOKEN_ID_1" },
  { tokenId: "TOKEN_ID_2" },
]);

获取价格历史

PublicClient 和 SecureClient 均提供价格历史功能。将所有参数传入一个请求对象；响应使用 camelCase 字段和类型化的时间戳。

Before

const history = await client.getPricesHistory({
  market: "TOKEN_ID",
  interval: "1d",
  fidelity: 60,
});

After

import { PriceHistoryInterval } from "@polymarket/client";

const history = await client.fetchPriceHistory({
  tokenId: "TOKEN_ID",
  interval: PriceHistoryInterval.ONE_DAY,
  fidelity: 60,
});

估算市价单价格

PublicClient 和 SecureClient 均提供市价单价格估算。请求中需区分用于买入的抵押品支出与用于卖出的份额出售。

Before

const price = await client.calculateMarketPrice(
  "TOKEN_ID",
  Side.BUY,
  100,
  OrderType.FAK,
);

After

const price = await client.estimateMarketPrice({
  tokenId: "TOKEN_ID",
  side: OrderSide.BUY,
  amount: 100,
});

列出近期市场交易

PublicClient 和 SecureClient 均提供公开交易分页器，用于替代之前的市场事件响应。

Before

const trades = await client.getMarketTradesEvents("CONDITION_ID");

After

const pages = client.listTrades({ market: ["CONDITION_ID"] });
const page = await pages.firstPage();
const trades = page.items;

订单

提交限价单

SecureClient 在提交限价单前会解析最小变动价位、负风险状态、费用及签名详情。

Before

const response = await client.createAndPostOrder(
  {
    tokenID: "TOKEN_ID",
    price: 0.52,
    size: 10,
    side: Side.BUY,
  },
  { tickSize: "0.01", negRisk: false },
  OrderType.GTC,
);

After

const response = await client.placeLimitOrder({
  tokenId: "TOKEN_ID",
  price: 0.52,
  size: 10,
  side: OrderSide.BUY,
});

为 GTD 订单设置 expiration，为仅挂单订单设置 postOnly: true。

下市价单

SecureClient 用于下达市价单。买入时指定要花费的抵押品，卖出时指定要卖出的份额。

Before

const response = await client.createAndPostMarketOrder(
  {
    tokenID: "TOKEN_ID",
    amount: 10,
    userUSDCBalance: 10,
    side: Side.BUY,
  },
  { tickSize: "0.01", negRisk: false },
  OrderType.FAK,
);

After

const response = await client.placeMarketOrder({
  tokenId: "TOKEN_ID",
  amount: 10,
  maxSpend: 10,
  side: OrderSide.BUY,
  orderType: OrderType.FAK,
});

userUSDCBalance 变为 maxSpend。之前的字段提供用于调整手续费的账户余额；而统一 SDK 改为接受最大总花费金额。当金额应包含手续费时，将 maxSpend 设置为等于 amount；否则省略它以在额外支付适用手续费。

仅签名不发布

当签名和提交需要分开进行时，SecureClient 提供特定于订单类型的创建方法。

Before

const signedOrder = await client.createOrder(
  {
    tokenID: "TOKEN_ID",
    price: 0.52,
    size: 10,
    side: Side.BUY,
  },
  { tickSize: "0.01", negRisk: false },
);

const response = await client.postOrder(signedOrder, OrderType.GTC);

After

const signedOrder = await client.createLimitOrder({
  tokenId: "TOKEN_ID",
  price: 0.52,
  size: 10,
  side: OrderSide.BUY,
});

const response = await client.postOrder(signedOrder);

准备 FAK 或 FOK 市价单时，请使用 createMarketOrder。

发布多个订单

SecureClient 提供 postOrders。订单类型和仅挂单行为是每个已签名订单的一部分，因此该方法直接接受已签名的订单。

Before

const response = await client.postOrders([
  { order: firstOrder, orderType: OrderType.GTC },
  { order: secondOrder, orderType: OrderType.GTC },
]);

After

const response = await client.postOrders([firstOrder, secondOrder]);

将订单归属给 Builder

SecureClient 为每个订单附加 Builder 代码。

Before

const response = await client.createAndPostOrder(
  {
    tokenID: "TOKEN_ID",
    price: 0.52,
    size: 10,
    side: Side.BUY,
    builderCode: process.env.POLYMARKET_BUILDER_CODE,
  },
  { tickSize: "0.01", negRisk: false },
);

After

const response = await client.placeLimitOrder({
  tokenId: "TOKEN_ID",
  price: 0.52,
  size: 10,
  side: OrderSide.BUY,
  builderCode: process.env.POLYMARKET_BUILDER_CODE,
});

取消订单

SecureClient 提供取消方法。它们现在接受 camelCase 请求对象，而 cancelAll 仍无需参数。

Before

await client.cancelOrder("ORDER_ID");
await client.cancelOrders(["ORDER_ID_1", "ORDER_ID_2"]);
await client.cancelAll();
await client.cancelMarketOrders({
  market: "CONDITION_ID",
  asset_id: "TOKEN_ID",
});

After

await client.cancelOrder({ orderId: "ORDER_ID" });
await client.cancelOrders({ orderIds: ["ORDER_ID_1", "ORDER_ID_2"] });
await client.cancelAll();
await client.cancelMarketOrders({
  market: "CONDITION_ID",
  tokenId: "TOKEN_ID",
});

获取订单

SecureClient 使用请求对象通过 ID 获取订单。

Before

const order = await client.getOrder("ORDER_ID");

After

const order = await client.fetchOrder({ orderId: "ORDER_ID" });

列出未成交订单

SecureClient 提供 listOpenOrders，返回一个分页器。过滤条件和响应字段使用 camelCase（小驼峰命名法）。

Before

const orders = await client.getOpenOrders({
  market: "CONDITION_ID",
  asset_id: "TOKEN_ID",
});

After

const pages = client.listOpenOrders({
  market: "CONDITION_ID",
  tokenId: "TOKEN_ID",
});
const orders = [];
for await (const page of pages) {
  orders.push(...page.items);
}

检查订单评分

SecureClient 提供 fetchOrderScoring 用于单个订单，以及 fetchOrdersScoring 用于多个订单。

Before

const scoring = await client.isOrderScoring({ orderId: "ORDER_ID" });
const batch = await client.areOrdersScoring({
  orderIds: ["ORDER_ID_1", "ORDER_ID_2"],
});

After

const scoring = await client.fetchOrderScoring({ orderId: "ORDER_ID" });
const batch = await client.fetchOrdersScoring({
  orderIds: ["ORDER_ID_1", "ORDER_ID_2"],
});

账户活动与余额

列出账户交易

SecureClient 将之前的两种账户交易历史方法合并为一个分页器。

Before

const trades = await client.getTrades({ market: "CONDITION_ID" });
const page = await client.getTradesPaginated({ market: "CONDITION_ID" });

After

const pages = client.listAccountTrades({ market: "CONDITION_ID" });
const firstPage = await pages.firstPage();

const trades = [];
for await (const page of pages) {
  trades.push(...page.items);
}

列出 Builder 交易

PublicClient 和 SecureClient 均提供公开的 Builder 交易历史，可按 Builder 代码进行过滤。

Before

const trades = await client.getBuilderTrades();

After

const pages = client.listBuilderTrades({
  builderCode: process.env.POLYMARKET_BUILDER_CODE,
});
const page = await pages.firstPage();
const trades = page.items;

读取并清除通知

SecureClient 提供具有动作导向名称的通知方法以及 camelCase 格式的请求字段。

Before

const notifications = await client.getNotifications();
await client.dropNotifications({ ids: [1, 2] });

After

const notifications = await client.fetchNotifications();
await client.dropNotifications({ ids: ["1", "2"] });

刷新余额和授权额度

SecureClient 在下单时管理余额和授权额度。它会检测缺失的授权额度，完成所需的批准操作，刷新余额和授权额度，并重试下单。

Before

await client.updateBalanceAllowance({
  asset_type: AssetType.COLLATERAL,
});

const balance = await client.getBalanceAllowance({
  asset_type: AssetType.COLLATERAL,
});

After

const response = await client.placeLimitOrder({
  tokenId: "TOKEN_ID",
  price: 0.52,
  size: 10,
  side: OrderSide.BUY,
});

持仓

统一方法负责构建并提交钱包交易。你不再需要编码合约调用或将交易数组传递给 execute。

拆分持仓

SecureClient 将抵押品拆分为完整的 YES 和 NO 结果代币集合。

Before

const splitTx = {
  to: CTF_COLLATERAL_ADAPTER_ADDRESS,
  data: collateralAdapterInterface.encodeFunctionData("splitPosition", [
    PUSD_ADDRESS,
    ethers.constants.HashZero,
    conditionId,
    [1, 2],
    ethers.utils.parseUnits("1", 6),
  ]),
  value: "0",
};

const split = await relayer.execute([splitTx], "Split position");
await split.wait();

After

const split = await client.splitPosition({
  conditionId,
  amount: 1_000_000n,
});

await split.wait();

合并持仓

SecureClient 将平衡的 YES 和 NO 代币重新合并为抵押品。

Before

const mergeTx = {
  to: CTF_COLLATERAL_ADAPTER_ADDRESS,
  data: collateralAdapterInterface.encodeFunctionData("mergePositions", [
    PUSD_ADDRESS,
    ethers.constants.HashZero,
    conditionId,
    [1, 2],
    ethers.utils.parseUnits("1", 6),
  ]),
  value: "0",
};

const merge = await relayer.execute([mergeTx], "Merge positions");
await merge.wait();

After

const merge = await client.mergePositions({
  conditionId,
  amount: "max",
});

await merge.wait();

赎回已结算持仓

SecureClient 在结果确定后，将获胜的结果代币兑换为抵押品。

Before

const redeemTx = {
  to: CTF_COLLATERAL_ADAPTER_ADDRESS,
  data: collateralAdapterInterface.encodeFunctionData("redeemPositions", [
    PUSD_ADDRESS,
    ethers.constants.HashZero,
    conditionId,
    [1, 2],
  ]),
  value: "0",
};

const redeem = await relayer.execute([redeemTx], "Redeem positions");
await redeem.wait();

After

const redeem = await client.redeemPositions({ conditionId });
await redeem.wait();

服务状态

无需调用 PublicClient 或 SecureClient。统一客户端在内部管理请求时序。

Before

await client.getOk();
const timestamp = await client.getServerTime();

After

// No client call is required for request timestamp synchronization.

以下示例将之前的客户端功能映射到 polymarket-client。 SDK 还涵盖了 Gamma API 和 Data API。迁移直接的 Gamma 和 Data 调用可以简化应用程序代码，并提供与 SDK 的交易和账户工作流无缝配合的标准化、类型化模型。公共客户端提供无需身份验证的市场发现和数据读取。安全客户端增加了经过身份验证的交易、账户和钱包操作。 Python 提供了每个客户端的异步和同步版本，因此请选择与应用程序执行模型匹配的接口。

接口	客户端	适用场景
异步	`AsyncPublicClient`, `AsyncSecureClient`	使用事件循环的服务、机器人和应用程序
同步	`PublicClient`, `SecureClient`	脚本、笔记本和同步应用程序

以下示例使用异步客户端。

由于流式传输特性，某些功能仅通过异步客户端提供。

安装统一 SDK

移除旧版 CLOB、Relayer 和 Builder 签名包。然后安装统一 SDK。

uv remove py-clob-client-v2 py-builder-relayer-client py-builder-signing-sdk
uv add polymarket-client

pip uninstall -y py-clob-client-v2 py-builder-relayer-client py-builder-signing-sdk
pip install polymarket-client

poetry remove py-clob-client-v2 py-builder-relayer-client py-builder-signing-sdk
poetry add polymarket-client

客户端和钱包设置

创建公共客户端

AsyncPublicClient 提供无需身份验证的市场发现和数据读取。生产环境是默认环境。

Before

from py_clob_client_v2.client import ClobClient

client = ClobClient("https://clob.polymarket.com", chain_id=137)

After

from polymarket import AsyncPublicClient

client = AsyncPublicClient()

创建经过身份验证的客户端

AsyncSecureClient 提供经过身份验证的交易、账户和钱包操作。 create 派生或创建 CLOB 凭据，解析账户钱包，并配置签名。

Before

import os

from py_clob_client_v2.client import ClobClient
from py_clob_client_v2.order_utils.model import SignatureTypeV2

temporary_client = ClobClient(
    "https://clob.polymarket.com",
    chain_id=137,
    key=os.environ["POLYMARKET_PRIVATE_KEY"],
)
credentials = temporary_client.create_or_derive_api_key()

client = ClobClient(
    "https://clob.polymarket.com",
    chain_id=137,
    key=os.environ["POLYMARKET_PRIVATE_KEY"],
    creds=credentials,
    signature_type=SignatureTypeV2.POLY_1271,
    funder=os.environ["POLYMARKET_WALLET_ADDRESS"],
)

After

import os

from polymarket import AsyncSecureClient

client = await AsyncSecureClient.create(
    private_key=os.environ["POLYMARKET_PRIVATE_KEY"],
    wallet=os.environ["POLYMARKET_WALLET_ADDRESS"],
)

省略 wallet 以使用默认的 Deposit Wallet 流程。

使用现有凭据恢复

从经过身份验证的客户端读取凭据，安全存储它们，并将其传递给新客户端以使用相同的 API 密钥恢复。私钥和钱包必须标识拥有该凭据的账户。

Before

import os

from py_clob_client_v2.client import ClobClient
from py_clob_client_v2.order_utils.model import SignatureTypeV2

credentials = client.creds
if credentials is None:
    raise RuntimeError("Client has no credentials")

# Store the credentials securely.

resumed_client = ClobClient(
    "https://clob.polymarket.com",
    chain_id=137,
    key=os.environ["POLYMARKET_PRIVATE_KEY"],
    creds=credentials,
    signature_type=SignatureTypeV2.POLY_1271,
    funder=os.environ["POLYMARKET_WALLET_ADDRESS"],
)

After

import os

from polymarket import AsyncSecureClient

credentials = client.credentials

# Store the credentials securely.

resumed_client = await AsyncSecureClient.create(
    private_key=os.environ["POLYMARKET_PRIVATE_KEY"],
    wallet=os.environ["POLYMARKET_WALLET_ADDRESS"],
    credentials=credentials,
)

撤销当前 API 密钥

结束身份验证将撤销当前 API 密钥，使 AsyncSecureClient 失效，并返回 AsyncPublicClient。

Before

client.delete_api_key()

After

public_client = await client.end_authentication()

配置 Builder API 密钥

AsyncSecureClient 接受用于无 Gas 钱包操作的 BuilderApiKey。请将 key、secret 和 passphrase 保存在服务器端。

Before

import os

from py_builder_relayer_client.client import RelayClient
from py_builder_signing_sdk.config import BuilderConfig
from py_builder_signing_sdk.sdk_types import BuilderApiKeyCreds

builder_config = BuilderConfig(
    local_builder_creds=BuilderApiKeyCreds(
        key=os.environ["POLYMARKET_BUILDER_API_KEY"],
        secret=os.environ["POLYMARKET_BUILDER_SECRET"],
        passphrase=os.environ["POLYMARKET_BUILDER_PASSPHRASE"],
    )
)

relayer = RelayClient(
    "https://relayer-v2.polymarket.com",
    137,
    os.environ["POLYMARKET_PRIVATE_KEY"],
    builder_config,
)

After

import os

from polymarket import AsyncSecureClient, BuilderApiKey

client = await AsyncSecureClient.create(
    private_key=os.environ["POLYMARKET_PRIVATE_KEY"],
    api_key=BuilderApiKey(
        key=os.environ["POLYMARKET_BUILDER_API_KEY"],
        secret=os.environ["POLYMARKET_BUILDER_SECRET"],
        passphrase=os.environ["POLYMARKET_BUILDER_PASSPHRASE"],
    ),
)

配置 Relayer API 密钥

AsyncSecureClient 直接配置 Relayer API 密钥。在重新连接现有账户时，传递密钥及其关联的地址。

import os

from polymarket import AsyncSecureClient, RelayerApiKey

client = await AsyncSecureClient.create(
    private_key=os.environ["POLYMARKET_PRIVATE_KEY"],
    wallet=os.environ["POLYMARKET_WALLET_ADDRESS"],
    api_key=RelayerApiKey(
        key=os.environ["POLYMARKET_RELAYER_API_KEY"],
        address=os.environ["POLYMARKET_RELAYER_API_KEY_ADDRESS"],
    ),
)

部署 Deposit Wallet

在不提供 wallet 的情况下创建 AsyncSecureClient 会派生签名者的 Deposit Wallet 地址，并在需要时进行部署。使用 Builder 授权来批准该部署。

Before

deployment = relayer.deploy_deposit_wallet()
deployment.wait()

After

import os

from polymarket import AsyncSecureClient, BuilderApiKey

client = await AsyncSecureClient.create(
    private_key=os.environ["POLYMARKET_PRIVATE_KEY"],
    api_key=BuilderApiKey(
        key=os.environ["POLYMARKET_BUILDER_API_KEY"],
        secret=os.environ["POLYMARKET_BUILDER_SECRET"],
        passphrase=os.environ["POLYMARKET_BUILDER_PASSPHRASE"],
    ),
)

deposit_wallet_address = client.wallet

市场发现

获取市场

AsyncPublicClient 和 AsyncSecureClient 均提供 get_market，用于通过 Gamma 市场 ID、slug 或 Polymarket URL 读取数据。

Before

market = client.get_market("CONDITION_ID")

After

market = await client.get_market(slug="MARKET_SLUG")

如果你只有条件 ID，请筛选 list_markets 并获取其第一页。

pages = client.list_markets(condition_ids=["CONDITION_ID"])
page = await pages.first_page()
market = page.items[0]

列出市场

AsyncPublicClient 和 AsyncSecureClient 均提供 list_markets，它返回一个异步分页器并支持直接传入筛选条件。

Before

page = client.get_markets()
markets = page["data"]

After

pages = client.list_markets(closed=False, page_size=20)
page = await pages.first_page()
markets = page.items

简化版市场读取无需单独的替换方案。采样市场读取迁移至 list_current_rewards，用于列出当前的奖励配置。

Before

markets = client.get_sampling_markets()
page = client.get_sampling_simplified_markets()

After

pages = client.list_current_rewards()
page = await pages.first_page()

市场数据

读取交易参数

AsyncPublicClient 和 AsyncSecureClient 返回市场模型中的 tick size 和负风险状态。订单方法也会自动解析这些值。

Before

tick_size = client.get_tick_size("TOKEN_ID")
neg_risk = client.get_neg_risk("TOKEN_ID")
fee_rate_bps = client.get_fee_rate_bps("TOKEN_ID")

After

market = await client.get_market(slug="MARKET_SLUG")
tick_size = market.trading.minimum_tick_size
neg_risk = market.state.neg_risk
fee_schedule = market.trading.fee_schedule

读取 CLOB 市场详情

AsyncPublicClient 和 AsyncSecureClient 返回类型化的市场模型。其交易字段取代了紧凑的 CLOB 市场响应。

Before

details = client.get_clob_market_info("CONDITION_ID")
tick_size = details["mts"]
neg_risk = details["nr"]
fee_details = details["fd"]

After

market = await client.get_market(slug="MARKET_SLUG")
tick_size = market.trading.minimum_tick_size
neg_risk = market.state.neg_risk
fee_schedule = market.trading.fee_schedule

获取订单簿

AsyncPublicClient 和 AsyncSecureClient 均提供单次和批量的订单簿读取功能。

Before

from py_clob_client_v2 import BookParams

book = client.get_order_book("TOKEN_ID")
books = client.get_order_books(
    [BookParams(token_id="TOKEN_ID_1"), BookParams(token_id="TOKEN_ID_2")]
)

After

book = await client.get_order_book(token_id="TOKEN_ID")
books = await client.get_order_books(token_ids=["TOKEN_ID_1", "TOKEN_ID_2"])

获取价格

AsyncPublicClient 和 AsyncSecureClient 均提供带有类型化请求的单次和批量价格读取功能。

Before

from py_clob_client_v2 import BookParams, Side

price = client.get_price("TOKEN_ID", Side.BUY)
prices = client.get_prices(
    [
        BookParams(token_id="TOKEN_ID_1", side=Side.BUY),
        BookParams(token_id="TOKEN_ID_2", side=Side.SELL),
    ]
)

After

from polymarket import PriceRequest

price = await client.get_price(token_id="TOKEN_ID", side="BUY")
prices = await client.get_prices(
    requests=[
        PriceRequest(token_id="TOKEN_ID_1", side="BUY"),
        PriceRequest(token_id="TOKEN_ID_2", side="SELL"),
    ]
)

获取中间价

AsyncPublicClient 和 AsyncSecureClient 均提供单次和批量的中间价读取功能。

Before

from py_clob_client_v2 import BookParams

midpoint = client.get_midpoint("TOKEN_ID")
midpoints = client.get_midpoints(
    [BookParams(token_id="TOKEN_ID_1"), BookParams(token_id="TOKEN_ID_2")]
)

After

midpoint = await client.get_midpoint(token_id="TOKEN_ID")
midpoints = await client.get_midpoints(token_ids=["TOKEN_ID_1", "TOKEN_ID_2"])

获取价差

AsyncPublicClient 和 AsyncSecureClient 均提供单次和批量的价差读取功能。

Before

from py_clob_client_v2 import BookParams

spread = client.get_spread("TOKEN_ID")
spreads = client.get_spreads(
    [BookParams(token_id="TOKEN_ID_1"), BookParams(token_id="TOKEN_ID_2")]
)

After

spread = await client.get_spread(token_id="TOKEN_ID")
spreads = await client.get_spreads(token_ids=["TOKEN_ID_1", "TOKEN_ID_2"])

获取最新成交价

AsyncPublicClient 和 AsyncSecureClient 均提供用于获取最新成交价的单次和批量方法。

Before

from py_clob_client_v2 import BookParams

last_trade = client.get_last_trade_price("TOKEN_ID")
last_trades = client.get_last_trades_prices(
    [BookParams(token_id="TOKEN_ID_1"), BookParams(token_id="TOKEN_ID_2")]
)

After

last_trade = await client.get_last_trade_price(token_id="TOKEN_ID")
last_trades = await client.get_last_trade_prices(
    token_ids=["TOKEN_ID_1", "TOKEN_ID_2"]
)

获取价格历史

AsyncPublicClient 和 AsyncSecureClient 均提供价格历史数据。将参数作为关键字参数传递，响应中包含类型化的数据点。

Before

from py_clob_client_v2 import PricesHistoryParams

history = client.get_prices_history(
    PricesHistoryParams(market="TOKEN_ID", interval="1d", fidelity=60)
)

After

history = await client.get_price_history(
    token_id="TOKEN_ID",
    interval="1d",
    fidelity=60,
)

估算市价单价格

AsyncPublicClient 和 AsyncSecureClient 均提供市价单价格估算。买入时指定花费的抵押品，卖出时指定出售的份额数量。

Before

from py_clob_client_v2 import OrderType, Side

buy_price = client.calculate_market_price(
    "TOKEN_ID", Side.BUY, 10, OrderType.FOK
)
sell_price = client.calculate_market_price(
    "TOKEN_ID", Side.SELL, 5, OrderType.FOK
)

After

buy_price = await client.estimate_market_price(
    token_id="TOKEN_ID", side="BUY", amount=10, order_type="FOK"
)
sell_price = await client.estimate_market_price(
    token_id="TOKEN_ID", side="SELL", shares=5, order_type="FOK"
)

列出近期市场交易

AsyncPublicClient 和 AsyncSecureClient 均提供公共交易分页器，用于替代之前的市场事件响应。

Before

trades = client.get_market_trades_events("CONDITION_ID")

After

pages = client.list_trades(market=["CONDITION_ID"])
page = await pages.first_page()
trades = page.items

订单

提交限价单

AsyncSecureClient 在提交限价单前会解析最小变动价位、负风险状态、费用以及签名详情。

Before

from py_clob_client_v2 import OrderArgs, Side

response = client.create_and_post_order(
    OrderArgs(
        token_id="TOKEN_ID",
        price=0.52,
        size=10,
        side=Side.BUY,
    )
)

After

response = await client.place_limit_order(
    token_id="TOKEN_ID",
    price=0.52,
    size=10,
    side="BUY",
)

提交市价单

AsyncSecureClient 用于提交市价单。买入时指定要花费的金额，卖出时指定要出售的份额数量。

Before

from py_clob_client_v2 import MarketOrderArgs, OrderType, Side

response = client.create_and_post_market_order(
    MarketOrderArgs(
        token_id="TOKEN_ID",
        amount=10,
        user_usdc_balance=10,
        side=Side.BUY,
    ),
    order_type=OrderType.FOK,
)

After

response = await client.place_market_order(
    token_id="TOKEN_ID",
    side="BUY",
    amount=10,
    max_spend=10,
    order_type="FOK",
)

user_usdc_balance 变为 max_spend。之前的字段提供用于调整订单费用的账户余额；而统一的 SDK 改为接受最大总支出金额。当金额应包含费用时，将 max_spend 设置为与 amount 相等；若希望额外支付适用费用，则省略该字段。

仅签名不发布

当签名和提交需要分开进行时，AsyncSecureClient 提供特定于订单类型的创建方法。

Before

from py_clob_client_v2 import MarketOrderArgs, OrderArgs, Side

limit_order = client.create_order(
    OrderArgs(token_id="TOKEN_ID", price=0.52, size=10, side=Side.BUY)
)
market_order = client.create_market_order(
    MarketOrderArgs(token_id="TOKEN_ID", amount=10, side=Side.BUY)
)

After

limit_order = await client.create_limit_order(
    token_id="TOKEN_ID",
    price=0.52,
    size=10,
    side="BUY",
)
market_order = await client.create_market_order(
    token_id="TOKEN_ID",
    side="BUY",
    amount=10,
)

发布多笔订单

AsyncSecureClient 提供 post_orders。订单类型和仅挂单行为是每个签名订单的一部分，因此该方法直接接受签名订单。

Before

from py_clob_client_v2 import OrderType, PostOrdersV2Args

responses = client.post_orders(
    [
        PostOrdersV2Args(order=first_order, orderType=OrderType.GTC),
        PostOrdersV2Args(order=second_order, orderType=OrderType.GTC),
    ]
)

After

responses = await client.post_orders([first_order, second_order])

将订单归属给 Builder

AsyncSecureClient 将 Builder 代码附加到每个订单。

Before

from py_clob_client_v2 import OrderArgs, Side

response = client.create_and_post_order(
    OrderArgs(
        token_id="TOKEN_ID",
        price=0.52,
        size=10,
        side=Side.BUY,
        builder_code="BUILDER_CODE",
    )
)

After

response = await client.place_limit_order(
    token_id="TOKEN_ID",
    price=0.52,
    size=10,
    side="BUY",
    builder_code="BUILDER_CODE",
)

取消订单

AsyncSecureClient 提供用于取消单笔订单、多笔订单、所有订单或特定市场订单的显式方法。

Before

from py_clob_client_v2 import OrderMarketCancelParams, OrderPayload

client.cancel_order(OrderPayload(orderID="ORDER_ID"))
client.cancel_orders(["ORDER_ID_1", "ORDER_ID_2"])
client.cancel_market_orders(OrderMarketCancelParams(market="CONDITION_ID"))
client.cancel_all()

After

await client.cancel_order(order_id="ORDER_ID")
await client.cancel_orders(order_ids=["ORDER_ID_1", "ORDER_ID_2"])
await client.cancel_market_orders(market="CONDITION_ID")
await client.cancel_all()

获取订单

AsyncSecureClient 使用关键字参数通过 ID 获取订单。

Before

order = client.get_order("ORDER_ID")

After

order = await client.get_order(order_id="ORDER_ID")

列出未成交订单

AsyncSecureClient 提供 list_open_orders，返回一个异步分页器。

Before

from py_clob_client_v2 import OpenOrderParams

orders = client.get_open_orders(
    OpenOrderParams(market="CONDITION_ID", asset_id="TOKEN_ID")
)

After

pages = client.list_open_orders(market="CONDITION_ID", token_id="TOKEN_ID")
orders = [order async for order in pages.iter_items()]

检查订单评分

AsyncSecureClient 提供 get_order_scoring（用于单笔订单）和 get_orders_scoring（用于多笔订单）。

Before

from py_clob_client_v2 import OrderScoringParams, OrdersScoringParams

scoring = client.is_order_scoring(OrderScoringParams(orderId="ORDER_ID"))
batch = client.are_orders_scoring(
    OrdersScoringParams(orderIds=["ORDER_ID_1", "ORDER_ID_2"])
)

After

scoring = await client.get_order_scoring(order_id="ORDER_ID")
batch = await client.get_orders_scoring(
    order_ids=["ORDER_ID_1", "ORDER_ID_2"]
)

账户活动与余额

列出账户交易

AsyncSecureClient 将之前的两种账户交易历史方法合并为一个异步分页器。

Before

from py_clob_client_v2 import TradeParams

trades = client.get_trades(TradeParams(market="CONDITION_ID"))
page = client.get_trades_paginated(TradeParams(market="CONDITION_ID"))

After

pages = client.list_account_trades(market="CONDITION_ID")
first_page = await pages.first_page()

trades = [trade async for trade in pages.iter_items()]

列出 Builder 交易

AsyncPublicClient 和 AsyncSecureClient 均提供按 Builder 代码过滤的公开 Builder 交易历史。

Before

from py_clob_client_v2 import BuilderTradeParams

page = client.get_builder_trades(
    BuilderTradeParams(builder_code="BUILDER_CODE")
)
trades = page["trades"]

After

pages = client.list_builder_trades(builder_code="BUILDER_CODE")
page = await pages.first_page()
trades = page.items

读取并清除通知

AsyncSecureClient 提供带有关键字参数和类型化响应的通知方法。

Before

from py_clob_client_v2 import DropNotificationParams

notifications = client.get_notifications()
client.drop_notifications(DropNotificationParams(ids=[1, 2]))

After

notifications = await client.get_notifications()
await client.drop_notifications(ids=["1", "2"])

刷新余额与授权额度

AsyncSecureClient 在下单时读取余额并管理缺失的授权额度。它会完成所需的批准、刷新授权额度并重试订单。

Before

from py_clob_client_v2 import AssetType, BalanceAllowanceParams

params = BalanceAllowanceParams(asset_type=AssetType.COLLATERAL)
client.update_balance_allowance(params)
balance = client.get_balance_allowance(params)

After

balance = await client.get_balance_allowance(asset_type="COLLATERAL")
response = await client.place_limit_order(
    token_id="TOKEN_ID",
    price=0.52,
    size=10,
    side="BUY",
)

持仓

统一的方法会构建并提交钱包交易。你不再需要编码合约调用或将交易数组传递给 execute。

拆分持仓

AsyncSecureClient 将抵押品拆分为完整的 YES 和 NO 结果代币。

Before

from py_builder_relayer_client.models import Transaction

split_tx = Transaction(
    to=CTF_COLLATERAL_ADAPTER_ADDRESS,
    data=collateral_adapter.encode_abi(
        "splitPosition",
        args=[PUSD_ADDRESS, bytes(32), CONDITION_ID, [1, 2], 1_000_000],
    ),
    value="0",
)

split = relayer.execute([split_tx], "Split position")
split.wait()

After

split = await client.split_position(
    condition_id="CONDITION_ID",
    amount=1_000_000,
)
await split.wait()

合并持仓

AsyncSecureClient 将平衡的 YES 和 NO 代币重新合并为抵押品。

Before

from py_builder_relayer_client.models import Transaction

merge_tx = Transaction(
    to=CTF_COLLATERAL_ADAPTER_ADDRESS,
    data=collateral_adapter.encode_abi(
        "mergePositions",
        args=[PUSD_ADDRESS, bytes(32), CONDITION_ID, [1, 2], 1_000_000],
    ),
    value="0",
)

merge = relayer.execute([merge_tx], "Merge positions")
merge.wait()

After

merge = await client.merge_positions(
    condition_id="CONDITION_ID",
    amount="max",
)
await merge.wait()

赎回已结算持仓

AsyncSecureClient 在结果确定后，将获胜的结果代币兑换为抵押品。

Before

from py_builder_relayer_client.models import Transaction

redeem_tx = Transaction(
    to=CTF_COLLATERAL_ADAPTER_ADDRESS,
    data=collateral_adapter.encode_abi(
        "redeemPositions",
        args=[PUSD_ADDRESS, bytes(32), CONDITION_ID, [1, 2]],
    ),
    value="0",
)

redeem = relayer.execute([redeem_tx], "Redeem positions")
redeem.wait()

After

redeem = await client.redeem_positions(condition_id="CONDITION_ID")
await redeem.wait()

服务状态

AsyncPublicClient 和 AsyncSecureClient 均不需要这些调用。统一客户端在内部管理请求时序。

Before

client.get_ok()
timestamp = client.get_server_time()

After

# No client call is required for request timestamp synchronization.

统一的 Rust SDK 正在开发中。在它可用之前，请使用 polymarket_client_sdk_v2 0.7.0（当前的 Rust SDK）。有关完整的 API 和示例，请参阅 GitHub 仓库以及 crates.io 上的 polymarket_client_sdk_v2 包。

安装 Rust SDK

启用 clob 功能以进行身份验证和交易：

cargo add polymarket_client_sdk_v2@0.7.0 --features clob

使用 Deposit Wallet 交易

Rust SDK 支持现有 Deposit Wallet 的 CLOB 订单路径。它不包含用于部署 Deposit Wallet 或提交钱包批次的客户端；请针对这些操作使用 Direct API 工作流。将已部署的 Deposit Wallet 作为资金提供方，并在认证时使用 SignatureType::Poly1271。此示例会刷新抵押品额度缓存，然后下达 GTC 限价买单：

use std::str::FromStr as _;

use alloy::signers::Signer as _;
use alloy::signers::local::LocalSigner;
use polymarket_client_sdk_v2::clob::types::request::UpdateBalanceAllowanceRequest;
use polymarket_client_sdk_v2::clob::types::{
    AssetType, OrderType, Side, SignatureType,
};
use polymarket_client_sdk_v2::clob::{Client, Config};
use polymarket_client_sdk_v2::types::{Address, Decimal, U256};
use polymarket_client_sdk_v2::{POLYGON, PRIVATE_KEY_VAR};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let host = "https://clob-v2.polymarket.com";
    let signer = LocalSigner::from_str(&std::env::var(PRIVATE_KEY_VAR)?)?
        .with_chain_id(Some(POLYGON));
    let deposit_wallet = Address::from_str(&std::env::var("DEPOSIT_WALLET")?)?;

    let client = Client::new(host, Config::default())?
        .authentication_builder(&signer)
        .funder(deposit_wallet)
        .signature_type(SignatureType::Poly1271)
        .authenticate()
        .await?;

    client
        .update_balance_allowance(
            UpdateBalanceAllowanceRequest::builder()
                .asset_type(AssetType::Collateral)
                .build(),
        )
        .await?;

    let response = client
        .limit_order()
        .token_id(U256::from_str(&std::env::var("TOKEN_ID")?)?)
        .side(Side::Buy)
        .price(Decimal::from_str("0.40")?)
        .size(Decimal::from_str("100")?)
        .order_type(OrderType::GTC)
        .build_sign_and_post(&signer)
        .await?;

    println!("order_id={} status={}", response.order_id, response.status);
    Ok(())
}

处理匹配引擎重启

在每次重试前重新构建并签署订单，因为 SignedOrder 在提交后会被消耗。将 HTTP 425 视为临时状态，并使用指数退避策略进行重试：

use polymarket_client_sdk_v2::error::{Kind, StatusCode};

let mut delay = std::time::Duration::from_secs(1);

for _ in 0..10 {
    let order = client.limit_order()
        .token_id(token_id).price(price).size(size).side(side)
        .build().await?;
    let signed = client.sign(&signer, order).await?;

    match client.post_order(signed).await {
        Ok(response) => return Ok(response),
        Err(err) if err.kind() == Kind::Status => {
            if let Some(status) = err.downcast_ref::<polymarket_client_sdk_v2::error::Status>() {
                if status.status_code == StatusCode::from_u16(425).unwrap() {
                    eprintln!("Engine restarting, retrying in {delay:?}...");
                    tokio::time::sleep(delay).await;
                    delay = (delay * 2).min(std::time::Duration::from_secs(30));
                    continue;
                }
            }
            return Err(err);
        }
        Err(err) => return Err(err),
    }
}

有关重启窗口、仅挂单时段（post-only period）和受限模式响应，请参阅匹配引擎重启。

​安装统一 SDK

​客户端和钱包设置

​创建公共客户端

​创建经过身份验证的客户端

​使用现有凭据恢复

​撤销当前 API 密钥

​配置 Builder API 密钥

​配置 Relayer API 密钥

​部署 Deposit Wallet

​市场发现

​获取市场

​列出市场

​市场数据

​读取交易参数

​读取 CLOB 市场详情

​获取订单簿

​获取价格

​获取中间价

​获取价差

​获取最新成交价

​获取价格历史

​估算市价单价格

​列出近期市场交易

​订单

​提交限价单

​下市价单

​仅签名不发布

​发布多个订单

​将订单归属给 Builder

​取消订单

​获取订单

​列出未成交订单

​检查订单评分

​账户活动与余额

​列出账户交易

​列出 Builder 交易

​读取并清除通知

​刷新余额和授权额度

​持仓

​拆分持仓

​合并持仓

​赎回已结算持仓

​服务状态

​安装统一 SDK

​客户端和钱包设置

​创建公共客户端

​创建经过身份验证的客户端

​使用现有凭据恢复

​撤销当前 API 密钥

​配置 Builder API 密钥

​配置 Relayer API 密钥

​部署 Deposit Wallet

​市场发现

​获取市场

​列出市场

​市场数据

​读取交易参数

​读取 CLOB 市场详情

​获取订单簿

​获取价格

​获取中间价

​获取价差

​获取最新成交价

​获取价格历史

​估算市价单价格

​列出近期市场交易

​订单

​提交限价单

​提交市价单

​仅签名不发布

​发布多笔订单

​将订单归属给 Builder

​取消订单

​获取订单

​列出未成交订单

​检查订单评分

​账户活动与余额

​列出账户交易

​列出 Builder 交易

​读取并清除通知

安装统一 SDK

客户端和钱包设置

创建公共客户端

创建经过身份验证的客户端

使用现有凭据恢复

撤销当前 API 密钥

配置 Builder API 密钥

配置 Relayer API 密钥

部署 Deposit Wallet

市场发现

获取市场

列出市场

市场数据

读取交易参数

读取 CLOB 市场详情

获取订单簿

获取价格

获取中间价

获取价差

获取最新成交价

获取价格历史

估算市价单价格

列出近期市场交易

订单

提交限价单

下市价单

仅签名不发布

发布多个订单

将订单归属给 Builder

取消订单

获取订单

列出未成交订单

检查订单评分

账户活动与余额

列出账户交易

列出 Builder 交易

读取并清除通知

刷新余额和授权额度

持仓

拆分持仓

合并持仓

赎回已结算持仓

服务状态

安装统一 SDK

客户端和钱包设置

创建公共客户端

创建经过身份验证的客户端

使用现有凭据恢复

撤销当前 API 密钥

配置 Builder API 密钥

配置 Relayer API 密钥

部署 Deposit Wallet

市场发现

获取市场

列出市场

市场数据

读取交易参数

读取 CLOB 市场详情

获取订单簿

获取价格

获取中间价

获取价差

获取最新成交价

获取价格历史

估算市价单价格

列出近期市场交易

订单

提交限价单

提交市价单

仅签名不发布

发布多笔订单

将订单归属给 Builder

取消订单

获取订单

列出未成交订单

检查订单评分

账户活动与余额

列出账户交易

列出 Builder 交易

读取并清除通知