from predict_sdk import (
    OrderBuilder,
    ChainId,
    Side,
    BuildOrderInput,
    LimitHelperInput,
)

# Create an OrderBuilder without a signer (read-only)
builder = OrderBuilder.make(ChainId.BNB_MAINNET)

# Calculate order amounts for a LIMIT order
amounts = builder.get_limit_order_amounts(
    LimitHelperInput(
        side=Side.BUY,
        price_per_share_wei=500000000000000000,  # 0.5 USDT per share
        quantity_wei=10000000000000000000,  # 10 shares
    )
)

print(f"Maker Amount: {amounts.maker_amount}")
print(f"Taker Amount: {amounts.taker_amount}")

# Build an order
order = builder.build_order(
    "LIMIT",
    BuildOrderInput(
        side=Side.BUY,
        token_id="YOUR_TOKEN_ID",
        maker_amount=str(amounts.maker_amount),
        taker_amount=str(amounts.taker_amount),
        fee_rate_bps=100,  # Get from GET /markets endpoint
    ),
)

from eth_account import Account
from predict_sdk import OrderBuilder, ChainId

# Create from private key
private_key = "0x..."  # Your private key
signer = Account.from_key(private_key)

# Or pass private key directly
builder = OrderBuilder.make(ChainId.BNB_MAINNET, private_key)

# Now you can sign orders and interact with contracts
typed_data = builder.build_typed_data(
    order,
    is_neg_risk=False,
    is_yield_bearing=False,
)

signed_order = builder.sign_typed_data_order(typed_data)
print(f"Signature: {signed_order.signature}")

# Set approvals for ALL market types (standard + yield-bearing) in one call
result = builder.set_approvals()

if result.success:
    print("All approvals set successfully!")
else:
    print("Some approvals failed")
    for tx in result.transactions:
        if not tx.success:
            print(f"Failed: {tx.cause}")

# Optional: limit the run to a single track
builder.set_approvals(is_yield_bearing=False)  # standard markets only
builder.set_approvals(is_yield_bearing=True)   # yield-bearing markets only

# Or set individual approvals
builder.set_ctf_exchange_approval(is_neg_risk=False, is_yield_bearing=False)
builder.set_ctf_exchange_allowance(is_neg_risk=False, is_yield_bearing=False)

ApprovalStep(
    id="ERC1155_APPROVAL:CTF_EXCHANGE",  # stable identifier: "{type}:{spender_key}"
    type="ERC1155_APPROVAL",             # or "ERC20_ALLOWANCE"
    spender="0x8BC0...B689",             # the contract being granted permission
    token="0x22DA...d244",               # the token contract (conditional tokens for ERC-1155, USDT for ERC-20)
    label="Approve Exchange",            # default copy
    description="Allows you to interact with the exchange.",
)

from predict_sdk import OrderBuilder, ChainId, Side, ApprovalScope

builder = OrderBuilder.make(ChainId.BNB_MAINNET, private_key)

# For a single operation on a market:
steps = builder.get_approval_steps(
    ApprovalScope(
        operation="TRADE",
        is_neg_risk=True,
        is_yield_bearing=False,
        # side=Side.BUY,  # optional TRADE narrowing
    )
)

# For onboarding, every approval across both market types (and, by default, both tracks):
all_steps = builder.get_all_approval_steps()  # or is_yield_bearing=False to limit to one track

builder = OrderBuilder.make(ChainId.BNB_MAINNET, private_key)

steps = builder.get_approval_steps(
    ApprovalScope(operation="TRADE", is_neg_risk=True, is_yield_bearing=False)
)

report = builder.run_approvals(
    steps,
    skip_satisfied=True,     # default
    stop_on_error=True,      # default
    on_progress=lambda p: update_ui(p.step.id, p.status),
)

if not report.success:
    failed = [s.step.id for s in report.steps if s.status == "failed"]
    raise RuntimeError(f"Approvals failed: {failed}")

# Async variant:
# report = await builder.run_approvals_async(steps, on_progress=...)

builder = OrderBuilder.make(ChainId.BNB_MAINNET, private_key)

# 1. Build the plan.
steps = builder.get_approval_steps(
    ApprovalScope(operation="TRADE", is_neg_risk=is_neg_risk, is_yield_bearing=is_yield_bearing)
)

# 2. Render the checklist, marking which are already satisfied.
for check in builder.check_approvals(steps):
    add_row(check.step.id, check.step.label, check.step.description,
            "done" if check.satisfied else "pending")

# 3. Run the remaining steps, updating each row as it progresses.
report = builder.run_approvals(
    steps,
    on_progress=lambda p: set_row_status(p.step.id, p.status),
)

builder = OrderBuilder.make(ChainId.BNB_MAINNET, private_key)
steps = builder.get_approval_steps(
    ApprovalScope(operation="SPLIT", is_neg_risk=False, is_yield_bearing=False)
)

# Batched pre-check to mark which steps are already done.
for check in builder.check_approvals(steps):
    if check.satisfied:
        continue  # already approved
    # set_approval is a raw send: ERC-20 defaults to MAX_UINT256, ERC-1155 to approved=True.
    # Pass approved=False to revoke, or amount=... to cap an allowance.
    result = builder.set_approval(check.step)
    if not result.success:
        break  # you decide whether to continue

from predict_sdk import OrderBuilder, ChainId, OrderBuilderOptions

builder = OrderBuilder.make(
    ChainId.BNB_MAINNET,
    private_key,  # Must be the Privy exported wallet
    OrderBuilderOptions(
        predict_account="0x...",  # Your Predict account address
    ),
)

from predict_sdk import OrderBuilder, ChainId, OrderBuilderOptions

builder = OrderBuilder.make(
    ChainId.BNB_MAINNET,
    private_key,
    OrderBuilderOptions(predict_account="0x..."),
)

# Sign a string message
signature = builder.sign_predict_account_message("Hello, world!")

# Or sign a pre-computed hash (useful for EIP-712 typed data)
signature = builder.sign_predict_account_message({"raw": "0x1234..."})

# Async version available
signature = await builder.sign_predict_account_message_async("Hello, world!")

from predict_sdk import MarketHelperInput, MarketHelperValueInput

# Market order by quantity (number of shares)
amounts = builder.get_market_order_amounts(
    MarketHelperInput(
        side=Side.BUY,
        quantity_wei=10000000000000000000,  # 10 shares
    ),
    orderbook,  # From GET /orderbook/{marketId}
)

# Market BUY by value (total USDT to spend)
amounts = builder.get_market_order_amounts(
    MarketHelperValueInput(
        side=Side.BUY,
        value_wei=5000000000000000000,  # 5 USDT
    ),
    orderbook,
)

print(f"Maker Amount: {amounts.maker_amount}")
print(f"Taker Amount: {amounts.taker_amount}")
print(f"Amount: {amounts.amount}")
print(f"Price Per Share: {amounts.price_per_share}")
print(f"Slippage Applied: {amounts.slippage_bps} bps")
print(f"Is Min Amount Out: {amounts.is_min_amount_out}")

# BUY with slippage
amounts = builder.get_market_order_amounts(
    MarketHelperInput(
        side=Side.BUY,
        quantity_wei=10000000000000000000,  # 10 shares
        slippage_bps=100,  # 1% slippage tolerance
        is_min_amount_out=True,
    ),
    orderbook,
)

print(f"Maker Amount (cost): {amounts.maker_amount}")
print(f"Taker Amount (min shares out): {amounts.taker_amount}")
print(f"Amount (actual shares): {amounts.amount}")
print(f"Slippage: {amounts.slippage_bps} bps")  # 100

# Value-based BUY with slippage
amounts = builder.get_market_order_amounts(
    MarketHelperValueInput(
        side=Side.BUY,
        value_wei=5000000000000000000,  # 5 USDT
        slippage_bps=50,  # 0.5% slippage tolerance
        is_min_amount_out=True,
    ),
    orderbook,
)

# For standard markets
result = builder.redeem_positions(
    condition_id="0x...",
    index_set=1,  # 1 or 2
    is_neg_risk=False,
    is_yield_bearing=False,
)

# For NegRisk (winner-takes-all) markets
result = builder.redeem_positions(
    condition_id="0x...",
    index_set=1,
    amount=1000000000000000000,  # Required for NegRisk
    is_neg_risk=True,
    is_yield_bearing=False,
)

# For standard markets
result = builder.merge_positions(
    condition_id="0x...",
    amount=1000000000000000000,  # Amount to merge (in wei)
    is_neg_risk=False,
    is_yield_bearing=False,
)

# For NegRisk (winner-takes-all) markets
result = builder.merge_positions(
    condition_id="0x...",
    amount=1000000000000000000,
    is_neg_risk=True,
    is_yield_bearing=False,
)

from predict_sdk import CancelOrdersOptions

result = builder.cancel_orders(
    orders=[order1, order2],
    options=CancelOrdersOptions(
        is_neg_risk=False,
        is_yield_bearing=False,
    ),
)

balance = builder.balance_of("USDT")
print(f"USDT Balance: {balance}")

import asyncio

async def main():
    balance = await builder.balance_of_async("USDT")
    result = await builder.set_approvals_async()

asyncio.run(main())

OrderBuilder.make(
    chain_id: ChainId,
    signer: LocalAccount | str | None = None,
    options: OrderBuilderOptions | None = None,
) -> OrderBuilder

from predict_sdk import (
    ChainId,       # BNB_MAINNET (56), BNB_TESTNET (97)
    Side,          # BUY (0), SELL (1)
    SignatureType, # Only supports EOA (0)
    Order,
    SignedOrder,
    BuildOrderInput,
    OrderAmounts,
    LimitHelperInput,
    MarketHelperInput,
    MarketHelperValueInput,
    Book,
    EIP712TypedData,
    TransactionResult,
    SetApprovalsResult,
    CancelOrdersOptions,
    OrderBuilderOptions,
    # Scoped approvals
    ApprovalScope,        # operation + is_neg_risk + is_yield_bearing + side?
    ApprovalStep,         # id, type, spender, token, label, description
    ApprovalCheck,        # step + satisfied
    ApprovalProgress,     # step + status + transaction (on_progress payload)
    ApprovalStepResult,   # step + status + transaction (report entry)
    ApprovalRunReport,    # success + steps
)