管理仓位

在订单簿之外管理仓位：将抵押品拆分为完整的结果代币集、将配对代币合并回抵押品，或在结算后赎回获胜代币。根据你希望如何改变仓位来选择操作：

操作	适用场景
拆分	需要将抵押品转换为一套完整的结果代币。
合并	持有配对的结果代币，并希望将其转换回抵押品。
赎回	市场已经结算，希望为获胜仓位领取抵押品。

选择用于提交仓位操作的集成界面。

TypeScript
Python
API
Solidity

本页面的示例假设你已有一个配置了 Relayer API key 或 Builder API key 的 SecureClient。

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

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

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.SIGNER_PRIVATE_KEY),
  wallet: process.env.POLYMARKET_WALLET_ADDRESS,
  apiKey: builderApiKey({
    key: process.env.POLYMARKET_BUILDER_API_KEY!,
    secret: process.env.POLYMARKET_BUILDER_SECRET!,
    passphrase: process.env.POLYMARKET_BUILDER_PASSPHRASE!,
  }),
});

有关完整的钱包设置和 Relayer 授权流程，请参阅钱包与身份验证。

本页面的示例假设你已有一个配置了 Relayer API key 或 Builder API key 的 AsyncSecureClient。

import os

from polymarket import AsyncSecureClient, RelayerApiKey

client = await AsyncSecureClient.create(
    private_key=os.environ["SIGNER_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"],
    ),
)

import os

from polymarket import AsyncSecureClient, BuilderApiKey

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

同步 SecureClient 提供相同方法，并支持这两种 API key 类型。有关完整的钱包设置和 Relayer 授权流程，请参阅钱包与身份验证。

本页面的示例假设你可以使用 Relayer API key 或 Builder API key 对 Relayer API 请求进行身份验证。以下示例使用 Relayer API key：

RELAYER_API_KEY="<relayer_api_key>"
RELAYER_API_KEY_ADDRESS="<signer_address>"

有关完整的钱包设置和 Relayer 授权流程，请参阅执行免 Gas 交易。

本页面的示例使用以下 Polygon 合约：

合约	地址
pUSD	`0xC011a7E12a19f7B1f670d46F03B03f3342E82DFB`
Conditional Tokens	`0x4D97DCd97eC945f40cF65F87097ACe5EA0476045`
`CtfCollateralAdapter`	`0xAdA100Db00Ca00073811820692005400218FcE1f`
`NegRiskCtfCollateralAdapter`	`0xadA2005600Dec949baf300f4C6120000bDB6eAab`

拆分仓位

拆分会将 pUSD 转换为一套完整的结果代币。每 1 pUSD 会产生 1 个 YES 代币和 1 个 NO 代币。

100 pUSD → 100 YES tokens + 100 NO tokens

拆分前，请确保：

钱包中有足够的 pUSD 支付要拆分的金额。
已授权与市场类型对应的抵押品适配器使用钱包中的 pUSD。

TypeScript
Python
API
Solidity

在 SecureClient 上调用 splitPosition()。客户端会根据条件 ID 识别市场类型，并选择正确的抵押品适配器。

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

const outcome = await transaction.wait();

// outcome.transactionHash: TxHash
// outcome.transactionId: TransactionId | null

amount 以 pUSD 最小单位计价，因此 1_000_000n 会将 1 pUSD 拆分为 1 个 YES 代币和 1 个 NO 代币。交易结算后，wait() 会返回 TransactionOutcome。

在 AsyncSecureClient 上调用 split_position()。同步 SecureClient 提供相同方法。两个客户端都会根据条件 ID 识别市场类型，并选择正确的抵押品适配器。

transaction = await client.split_position(
    condition_id=market.condition_id,
    amount=1_000_000,
)

outcome = await transaction.wait()

# outcome.transaction_hash: TransactionHash
# outcome.transaction_id: str | None

amount 以 pUSD 最小单位计价，因此 1_000_000 会将 1 pUSD 拆分为 1 个 YES 代币和 1 个 NO 代币。交易结算后，wait() 会返回 TransactionOutcome。

构建 splitPosition 调用，然后将其作为免 Gas 钱包交易执行。

构建拆分调用

根据市场响应中的 negRisk 值选择调用目标：

`negRisk`	调用目标	地址
`false`	`CtfCollateralAdapter`	`0xAdA100Db00Ca00073811820692005400218FcE1f`
`true`	`NegRiskCtfCollateralAdapter`	`0xadA2005600Dec949baf300f4C6120000bDB6eAab`

对以下函数调用进行 ABI 编码：

function splitPosition(
    address collateralToken,
    bytes32 parentCollectionId,
    bytes32 conditionId,
    uint256[] partition,
    uint256 amount
);

参数	值
`collateralToken`	`0xC011a7E12a19f7B1f670d46F03B03f3342E82DFB`
`parentCollectionId`	32 个零字节
`conditionId`	`<market_condition_id>`
`partition`	`[1, 2]`
`amount`	`<amount_in_pusd_base_units>`

将编码后的 calldata 放入钱包调用：

{
  "target": "<collateral_adapter_address>",
  "value": "0",
  "data": "<encoded_split_position_calldata>"
}

执行拆分

对于 Deposit Wallet，将拆分调用包含在已签名的钱包批次中，并使用 Relayer API key 提交：

curl -X POST "https://relayer-v2.polymarket.com/submit" \
  -H "Content-Type: application/json" \
  -H "RELAYER_API_KEY: $RELAYER_API_KEY" \
  -H "RELAYER_API_KEY_ADDRESS: $RELAYER_API_KEY_ADDRESS" \
  --data '{
    "type": "WALLET",
    "from": "<signer_address>",
    "to": "0x00000000000Fb5C9ADea0298D729A0CB3823Cc07",
    "nonce": "<wallet_nonce>",
    "signature": "<wallet_batch_signature>",
    "metadata": "Split position",
    "depositWalletParams": {
      "depositWallet": "<deposit_wallet_address>",
      "deadline": "<unix_seconds>",
      "calls": [
        {
          "target": "<collateral_adapter_address>",
          "value": "0",
          "data": "<encoded_split_position_calldata>"
        }
      ]
    }
  }'

有关 nonce 创建、钱包批次签名和确认，请参阅执行免 Gas 交易。在使用新余额前，请等待 STATE_CONFIRMED。

通过抵押品适配器拆分 pUSD 的流程如下：

授权抵押品适配器使用要拆分的 pUSD 金额。
使用市场条件 ID 和金额调用适配器。
适配器执行底层 CTF 操作，并以原子方式铸造等量的 YES 和 NO 余额。

授权 pUSD

首先，在 pUSD 合约上调用 approve()。标准市场授权 CtfCollateralAdapter，负风险市场授权 NegRiskCtfCollateralAdapter：

function approve(address spender, uint256 amount) external returns (bool);

参数	值
`spender`	与市场类型对应的抵押品适配器
`amount`	要拆分的 pUSD 金额，以最小单位计

拆分仓位

然后，在刚才授权的同一合约上调用 splitPosition()：标准市场使用 CtfCollateralAdapter，负风险市场使用 NegRiskCtfCollateralAdapter：

function splitPosition(
    address collateralToken,
    bytes32 parentCollectionId,
    bytes32 conditionId,
    uint256[] partition,
    uint256 amount
);

参数	值
`collateralToken`	`0xC011a7E12a19f7B1f670d46F03B03f3342E82DFB`
`parentCollectionId`	32 个零字节
`conditionId`	市场的条件 ID
`partition`	`[1, 2]`
`amount`	要拆分的 pUSD 金额，以最小单位计

此调用会向调用者铸造等量的 YES 和 NO 代币。

合并仓位

合并会将一套完整的结果代币转换回 pUSD。每 1 个 YES 代币和 1 个 NO 代币会返还 1 pUSD。

100 YES tokens + 100 NO tokens → 100 pUSD

合并前，请确保：

持有等量的 YES 和 NO 代币。
已授权与市场类型对应的抵押品适配器转移钱包的结果代币。

TypeScript
Python
API
Solidity

在 SecureClient 上调用 mergePositions()。客户端会识别市场类型、选择正确的抵押品适配器，并检查钱包可合并的余额。

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

const outcome = await transaction.wait();

// outcome.transactionHash: TxHash
// outcome.transactionId: TransactionId | null

传入以最小单位计的 bigint 以合并指定金额。"max" 会合并钱包 YES 和 NO 余额中较小的一个。交易结算后，wait() 会返回 TransactionOutcome。

在 AsyncSecureClient 上调用 merge_positions()。同步 SecureClient 提供相同方法。两个客户端都会识别市场类型、选择正确的抵押品适配器，并检查钱包可合并的余额。

transaction = await client.merge_positions(
    condition_id=market.condition_id,
    amount="max",
)

outcome = await transaction.wait()

# outcome.transaction_hash: TransactionHash
# outcome.transaction_id: str | None

传入以最小单位计的 int 以合并指定金额。"max" 会合并钱包 YES 和 NO 余额中较小的一个。交易结算后，wait() 会返回 TransactionOutcome。

构建 mergePositions 调用，然后将其作为免 Gas 钱包交易执行。

构建合并调用

当 negRisk 为 false 时，使用地址为 0xAdA100Db00Ca00073811820692005400218FcE1f 的 CtfCollateralAdapter；为 true 时，使用地址为 0xadA2005600Dec949baf300f4C6120000bDB6eAab 的 NegRiskCtfCollateralAdapter。对以下函数调用进行 ABI 编码：

function mergePositions(
    address collateralToken,
    bytes32 parentCollectionId,
    bytes32 conditionId,
    uint256[] partition,
    uint256 amount
);

参数	值
`collateralToken`	`0xC011a7E12a19f7B1f670d46F03B03f3342E82DFB`
`parentCollectionId`	32 个零字节
`conditionId`	`<market_condition_id>`
`partition`	`[1, 2]`
`amount`	`<amount_in_pusd_base_units>`

将编码后的 calldata 放入钱包调用：

{
  "target": "<collateral_adapter_address>",
  "value": "0",
  "data": "<encoded_merge_positions_calldata>"
}

执行合并

对于 Deposit Wallet，将合并调用包含在已签名的钱包批次中，并使用 Relayer API key 提交：

curl -X POST "https://relayer-v2.polymarket.com/submit" \
  -H "Content-Type: application/json" \
  -H "RELAYER_API_KEY: $RELAYER_API_KEY" \
  -H "RELAYER_API_KEY_ADDRESS: $RELAYER_API_KEY_ADDRESS" \
  --data '{
    "type": "WALLET",
    "from": "<signer_address>",
    "to": "0x00000000000Fb5C9ADea0298D729A0CB3823Cc07",
    "nonce": "<wallet_nonce>",
    "signature": "<wallet_batch_signature>",
    "metadata": "Merge positions",
    "depositWalletParams": {
      "depositWallet": "<deposit_wallet_address>",
      "deadline": "<unix_seconds>",
      "calls": [
        {
          "target": "<collateral_adapter_address>",
          "value": "0",
          "data": "<encoded_merge_positions_calldata>"
        }
      ]
    }
  }'

有关 nonce 创建、钱包批次签名和确认，请参阅执行免 Gas 交易。在使用更新后的余额前，请等待 STATE_CONFIRMED。

通过抵押品适配器合并结果代币的流程如下：

授权抵押品适配器转移调用者的结果代币。
使用市场条件 ID 和要合并的金额调用适配器。
适配器销毁等量的 YES 和 NO 余额，并以原子方式返还 pUSD。

授权结果代币

首先，在 Conditional Tokens 合约上调用 setApprovalForAll()。标准市场授权 CtfCollateralAdapter，负风险市场授权 NegRiskCtfCollateralAdapter：

function setApprovalForAll(address operator, bool approved) external;

参数	值
`operator`	与市场类型对应的抵押品适配器
`approved`	`true`

合并仓位

然后，在刚才授权的同一合约上调用 mergePositions()：标准市场使用 CtfCollateralAdapter，负风险市场使用 NegRiskCtfCollateralAdapter：

function mergePositions(
    address collateralToken,
    bytes32 parentCollectionId,
    bytes32 conditionId,
    uint256[] partition,
    uint256 amount
);

参数	值
`collateralToken`	`0xC011a7E12a19f7B1f670d46F03B03f3342E82DFB`
`parentCollectionId`	32 个零字节
`conditionId`	市场的条件 ID
`partition`	`[1, 2]`
`amount`	要合并的每种结果代币数量

amount 不能超过任何一种结果代币的余额。此调用会向调用者返还等量的 pUSD。

赎回已结算仓位

市场结算后，赎回会将结果代币转换为 pUSD。每个获胜代币返还 1 pUSD，失败代币返还 0。

Market resolves YES:
100 YES tokens → 100 pUSD
100 NO tokens  → 0 pUSD

赎回没有截止日期。结算后，获胜代币可随时赎回。

赎回前，请确保：

市场已经结算。
持有该市场的结果代币。
已授权与市场类型对应的抵押品适配器转移钱包的结果代币。

TypeScript
Python
API
Solidity

在 SecureClient 上调用 redeemPositions()。客户端使用条件 ID 为市场类型选择正确的抵押品适配器。

const transaction = await client.redeemPositions({
  conditionId: market.conditionId,
});

const outcome = await transaction.wait();

// outcome.transactionHash: TxHash
// outcome.transactionId: TransactionId | null

赎回没有金额参数：它会赎回钱包中两种结果的全部余额。交易结算后， wait() 会返回 TransactionOutcome。

在 AsyncSecureClient 上调用 redeem_positions()。同步 SecureClient 提供相同方法。两个客户端都使用条件 ID 为市场类型选择正确的抵押品适配器。

transaction = await client.redeem_positions(
    condition_id=market.condition_id,
)

outcome = await transaction.wait()

# outcome.transaction_hash: TransactionHash
# outcome.transaction_id: str | None

赎回没有金额参数：它会赎回钱包中两种结果的全部余额。交易结算后， wait() 会返回 TransactionOutcome。

为已结算市场构建 redeemPositions 调用，然后将其作为免 Gas 钱包交易执行。

构建赎回调用

function redeemPositions(
    address collateralToken,
    bytes32 parentCollectionId,
    bytes32 conditionId,
    uint256[] indexSets
);

参数	值
`collateralToken`	`0xC011a7E12a19f7B1f670d46F03B03f3342E82DFB`
`parentCollectionId`	32 个零字节
`conditionId`	`<market_condition_id>`
`indexSets`	`[1, 2]`

将编码后的 calldata 放入钱包调用：

{
  "target": "<collateral_adapter_address>",
  "value": "0",
  "data": "<encoded_redeem_positions_calldata>"
}

执行赎回

对于 Deposit Wallet，将赎回调用包含在已签名的钱包批次中，并使用 Relayer API key 提交：

curl -X POST "https://relayer-v2.polymarket.com/submit" \
  -H "Content-Type: application/json" \
  -H "RELAYER_API_KEY: $RELAYER_API_KEY" \
  -H "RELAYER_API_KEY_ADDRESS: $RELAYER_API_KEY_ADDRESS" \
  --data '{
    "type": "WALLET",
    "from": "<signer_address>",
    "to": "0x00000000000Fb5C9ADea0298D729A0CB3823Cc07",
    "nonce": "<wallet_nonce>",
    "signature": "<wallet_batch_signature>",
    "metadata": "Redeem positions",
    "depositWalletParams": {
      "depositWallet": "<deposit_wallet_address>",
      "deadline": "<unix_seconds>",
      "calls": [
        {
          "target": "<collateral_adapter_address>",
          "value": "0",
          "data": "<encoded_redeem_positions_calldata>"
        }
      ]
    }
  }'

有关 nonce 创建、钱包批次签名和确认，请参阅执行免 Gas 交易。在使用收益前，请等待 STATE_CONFIRMED。

通过抵押品适配器赎回结果代币的流程如下：

授权抵押品适配器转移调用者的结果代币。
结算后，使用市场条件 ID 调用适配器。
适配器销毁两种结果的余额，并以原子方式以 pUSD 返还获胜收益。

授权结果代币

首先，在 Conditional Tokens 合约上调用 setApprovalForAll()。标准市场授权 CtfCollateralAdapter，负风险市场授权 NegRiskCtfCollateralAdapter：

function setApprovalForAll(address operator, bool approved) external;

参数	值
`operator`	与市场类型对应的抵押品适配器
`approved`	`true`

赎回仓位

然后，在刚才授权的同一合约上调用 redeemPositions()：标准市场使用 CtfCollateralAdapter，负风险市场使用 NegRiskCtfCollateralAdapter：

function redeemPositions(
    address collateralToken,
    bytes32 parentCollectionId,
    bytes32 conditionId,
    uint256[] indexSets
);

参数	值
`collateralToken`	`0xC011a7E12a19f7B1f670d46F03B03f3342E82DFB`
`parentCollectionId`	32 个零字节
`conditionId`	市场的条件 ID
`indexSets`	`[1, 2]`

此调用会赎回调用者在两个 index set 中的全部余额，并只返还获胜收益。

入门指南

核心概念

市场数据

交易

计划

资源

拆分仓位

合并仓位

赎回已结算仓位

​拆分仓位

​合并仓位

​赎回已结算仓位

拆分仓位

合并仓位

赎回已结算仓位