@dimes-dot-fi/sdk 1.4.3 → 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dimes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -9,7 +9,7 @@
 <p align="center">
   <a href="https://www.npmjs.com/package/@dimes-dot-fi/sdk"><img src="https://img.shields.io/npm/v/@dimes-dot-fi/sdk.svg" alt="npm version"></a>
   <a href="https://www.npmjs.com/package/@dimes-dot-fi/sdk"><img src="https://img.shields.io/npm/dm/@dimes-dot-fi/sdk.svg" alt="npm downloads"></a>
-  <a href="https://github.com/nicktids"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="license"></a>
+  <a href="https://github.com/dimes-fi/dimes-sdk/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="license"></a>
   <a href="https://docs.dimes.fi"><img src="https://img.shields.io/badge/docs-dimes.fi-black.svg" alt="docs"></a>
 </p>
 
@@ -93,7 +93,7 @@ const result = await executeQuote(client, {
   slippageBps: 300,
 });
 
-console.log(result.offer.entryPriceUsd);
+console.log(result.quote.entryPriceUsd);
 console.log(result.corrections); // auto-applied adjustments, if any
 ```
 
@@ -110,20 +110,75 @@ const result = await executeQuote(client, params, {
 
 ### Open a position on-chain
 
-```typescript
-import { buildCreatePositionTx, buildApproveTx, verifyOfferSignature } from "@dimes-dot-fi/sdk/contract";
+**Always verify the quote's signature before submitting.** The quote is signed by
+the Dimes authority over every term (size, leverage, fees, expiry); the vault
+enforces it on-chain (`InvalidSignature` / `SignatureExpired`), so verifying
+client-side just lets a tampered or stale quote fail fast instead of reverting.
 
-// Verify the quote signature
-await verifyOfferSignature(client, result.offer, userAddress);
+#### Recommended (mirrors the [dimes-demo-ui](https://github.com/dimes-fi/dimes-demo-ui) demo)
 
-// Build viem-compatible transactions
-const approveTx = buildApproveTx(usdcAddress, vaultAddress, amount);
-const createTx = buildCreatePositionTx(result.offer);
+Fetch `contract-info` once (it's cached), check the recovered signer with
+`assertQuoteSigner`, then build and submit the tx however your wallet stack
+requires. This keeps full control of your own UX and tx path while the SDK owns
+the crypto:
 
+```typescript
+import {
+  assertQuoteSigner,
+  resolveExpectedSigner,
+  getCachedContractInfo,
+  buildApproveTx,
+  buildCreatePositionTx,
+} from "@dimes-dot-fi/sdk/contract";
+import { getAddress } from "viem";
+
+const quote = result.quote;
+
+// The signed `user` is bound to msg.sender on-chain, so the submitting wallet
+// must be the one the quote was created for.
+const user = getAddress(quote.authorityPublicKey);
+if (getAddress(walletAddress) !== user) throw new Error("Wrong wallet for this quote.");
+
+// contract-info is cached per-client (staleTime: Infinity in React via useContractInfo()).
+const { polygonSignerAddress } = await getCachedContractInfo(client);
+const expectedSigner = resolveExpectedSigner(polygonSignerAddress);
+if (!expectedSigner) throw new Error("No signer address from /contract-info.");
+
+// Recover + compare. Throws DimesContractError("invalid_signer") on mismatch.
+await assertQuoteSigner(quote, user, expectedSigner);
+
+// Build viem-compatible transactions and submit them your way.
+const approveTx = buildApproveTx(usdcAddress, vaultAddress, BigInt(quote.totalUserAmountUsdcUnits));
+const createTx = buildCreatePositionTx(quote);
 await walletClient.writeContract(approveTx);
 await walletClient.writeContract(createTx);
 ```
 
+#### Primitives (build it differently)
+
+- `recoverCreatePositionSigner(quote, user)` — pure EIP-712 recovery; compare the
+  returned address yourself.
+- `buildCreatePositionTx`, `buildApproveTx`, `buildRequestCloseTx`,
+  `buildPushFundedCreateCalls`, `buildDepositWalletBatch` — raw call/tx builders
+  for EOA, smart-wallet (ERC-4337) batching, or deposit-wallet relayer flows. See
+  the three create-position hooks in dimes-ui for worked examples of each.
+
+#### Headless one-liners (no custom UX needed)
+
+For a bot or server that holds a `DimesClient` and doesn't need bespoke checks,
+these verify against the client's cached `contract-info` for you:
+
+```typescript
+import { buildVerifiedCreatePositionTx, buildVerifiedPushFundedCreateCalls } from "@dimes-dot-fi/sdk/contract";
+
+// verify-then-build in one call (throws on a bad signature):
+const createTx = await buildVerifiedCreatePositionTx(client, quote, user);
+const calls = await buildVerifiedPushFundedCreateCalls(client, quote, depositWallet); // pUSD address from contract-info
+```
+
+`verifyQuoteSignature(client, quote, user)` is the standalone verify if you want
+to build separately. (`verifyOfferSignature` is a deprecated alias.)
+
 ### Close a position
 
 ```typescript
@@ -215,17 +270,36 @@ Same API, same contracts, fake USDC. Get a sandbox key via the [Telegram link on
 | `GET /markets/:ticker` | `client.getMarket(ticker)` | `useMarket(ticker)` |
 | `GET /contract-info` | `client.getContractInfo()` | `useContractInfo()` |
 | `GET /positions` | `client.getPositions()` | `usePositions()` |
-| `GET /limits` | `client.getLimits()` | `useLimits()` |
+| `GET /user-limits` | `client.getUserLimits()` | `useUserLimits()` |
+| `GET /partner-limits` | `client.getPartnerLimits()` | `usePartnerLimits()` |
 | `POST /draft-quotes` | `client.createDraftQuote()` | — |
 | `POST /promoted-quotes/:id` | `client.promoteDraftQuote()` | — |
 | `POST /quotes` | `client.createQuote()` | — |
 | Draft → Promote (full flow) | `executeQuote()` | `useQuote()` |
 | Cancel position | `client.cancelPosition()` | `useCancelPosition()` |
 
+## Examples
+
+Runnable, type-checked examples live in [`examples/`](examples) — they're verified
+against the SDK source in CI (`pnpm examples:typecheck`), so they never drift from
+the real API:
+
+| File | Shows |
+| --- | --- |
+| [`01-quickstart.ts`](examples/01-quickstart.ts) | Auth, list markets, fetch an executable quote |
+| [`02-quote-engine.ts`](examples/02-quote-engine.ts) | `executeQuote` auto-correction + market-moved retries |
+| [`03-open-position-onchain.ts`](examples/03-open-position-onchain.ts) | EOA flow: approve → verify signature → `createPosition` (viem) |
+| [`04-positions-and-close.ts`](examples/04-positions-and-close.ts) | List positions, request an on-chain close |
+| [`05-websocket.ts`](examples/05-websocket.ts) | Stream live position events over Socket.IO |
+| [`react/trade-panel.tsx`](examples/react/trade-panel.tsx) | Provider + `useMarkets` + `useQuote` |
+| [`react/streams.tsx`](examples/react/streams.tsx) | `usePositions` with live WebSocket reconciliation |
+
 ## Documentation
 
 - [**Quickstart**](https://docs.dimes.fi/for-developers/quickstart) — end-to-end in 6 steps
 - [**SDK Installation**](https://docs.dimes.fi/for-developers/sdk-installation) — setup, auth, and peer deps
+- [**React Hooks**](https://docs.dimes.fi/for-developers/react-hooks) — provider, data hooks, quote state machine
+- [**WebSocket Events**](https://docs.dimes.fi/for-developers/websocket) — live position & market streams
 - [**API Reference**](https://docs.dimes.fi/for-developers/api-reference) — full endpoint documentation
 - [**Error Handling**](https://docs.dimes.fi/for-developers/error-handling) — error codes and structured hints
 - [**On-Chain Integration**](https://docs.dimes.fi/for-developers/on-chain-integration) — wallet patterns and contract ABIs
@@ -234,18 +308,13 @@ Same API, same contracts, fake USDC. Get a sandbox key via the [Telegram link on
 ## Publishing
 
 ```bash
-# Bump version
+# Bump version, then publish
 pnpm version patch   # or minor/major
-
-# Publish (pass the auth token inline to bypass 2FA requirement)
-npm publish --access public --registry https://registry.npmjs.org/ --//registry.npmjs.org/:_authToken=npm_XXXX
+npm publish --access public
 ```
 
-Then update the UI:
-```bash
-cd ~/bl/dimes-ui && pnpm add @dimes-dot-fi/sdk@<version>
-```
+The `prepublishOnly` hook runs lint, typecheck, tests, and build before publishing.
 
 ## License
 
-MIT
+[MIT](./LICENSE)

package/dist/{aliases-C2l_JZX_.d.cts → aliases-BJyM8ydu.d.cts}

@@ -32,12 +32,196 @@ interface components {
              * @example 0x70997970C51812dc3A010C7d01b50e0d17dc79C8
              */
             polygon_signer_address: string;
+            /**
+             * @description Checksummed address of the stablecoin (pUSD) token that collateral must be transferred in. Use this when building the push deposit transfer — sending any other token (e.g. USDC.e) will fail.
+             * @example 0xC011a7E12a19f7B1f670d46F03B03f3342E82DFB
+             */
+            polygon_usdc_token_address: string;
             /**
              * @description Checksummed address of the vault contract on Polygon
              * @example 0x9965507D1a55bcC2695C58ba16FB37d819B0A4dc
              */
             polygon_vault_contract_address: string;
         };
+        CustomerOriginationFeeTier: {
+            /**
+             * @description Upper leverage bound (inclusive) in basis points for this tier. The last tier is the catch-all.
+             * @example 40000
+             */
+            max_leverage_bps: number;
+            /**
+             * @description Protocol origination fee in basis points applied at or below this tier's leverage bound.
+             * @example 200
+             */
+            fee_bps: number;
+        };
+        CustomerFeeRatesMarket: {
+            /**
+             * @description Market ticker
+             * @example TRUMP-2024-WIN
+             */
+            ticker: string;
+            /**
+             * @description Polymarket venue trading fee rate in basis points (`feeRateBps`).
+             * @example 0
+             */
+            polymarket_trading_fee_bps: number;
+            /**
+             * @description Polymarket fee-curve exponent (`feeExponent`). `1` for the standard quadratic curve.
+             * @example 1
+             */
+            polymarket_fee_exponent: number;
+        };
+        CustomerFeeRates: {
+            /** @description Per-market venue fee fields. Only present when the request includes a `ticker` query parameter. */
+            market?: components["schemas"]["CustomerFeeRatesMarket"];
+            /** @description Leverage-tiered protocol origination fee schedule. Resolve a leverage to its fee by picking the first tier whose `maxLeverageBps >= leverageBps` (the last tier is the catch-all). */
+            origination_fee_tiers: components["schemas"]["CustomerOriginationFeeTier"][];
+            /**
+             * @description Maximum combined (protocol + partner) origination fee in basis points enforced on-chain.
+             * @example 1000
+             */
+            contract_max_origination_fee_bps: number;
+            /**
+             * @description Lifetime fee APR in basis points
+             * @example 2000
+             */
+            lifetime_fee_apr_bps: number;
+            /**
+             * @description Liquidation fee in basis points
+             * @example 250
+             */
+            liquidation_fee_bps: number;
+            /**
+             * @description This partner's origination fee component in basis points, added to the protocol tier fee. `0` by default.
+             * @example 0
+             */
+            partner_origination_fee_bps: number;
+            /**
+             * @description This partner's Polymarket builder taker fee in basis points (flat percentage of notional). `0` by default.
+             * @example 0
+             */
+            partner_trading_fee_bps: number;
+        };
+        FeeReportBody: {
+            /**
+             * @description Leverage in basis points (20000 = 2x, 100000 = 10x). Must be divisible by 2500. Maximum 10x.
+             * @example 50000
+             */
+            leverage_bps: number;
+            /**
+             * @description Market ticker
+             * @example TRUMP-2024-WIN
+             */
+            market_ticker: string;
+            /**
+             * @description Notional amount in USD pips (10,000 pips = $1.00)
+             * @example 50000
+             */
+            notional_amount_usd_pips: string;
+            /**
+             * @description Market side (yes or no)
+             * @enum {string}
+             */
+            effective_side: "yes" | "no";
+            /**
+             * @description Effective-side entry price in USD pips (10000 pips = $1) to compute against. When omitted, the market's current reference price is used. Provide it to compute deterministically against a known price.
+             * @example 5100
+             */
+            entry_price_usd_pips?: string;
+        };
+        CustomerFeeReport: {
+            /**
+             * @description Market ticker
+             * @example TRUMP-2024-WIN
+             */
+            market_ticker: string;
+            /**
+             * @description Market side
+             * @enum {string}
+             */
+            effective_side: "yes" | "no";
+            /**
+             * @description Leverage in basis points (20000 = 2x)
+             * @example 20000
+             */
+            leverage_bps: number;
+            /**
+             * @description Entry price used for the computation, in USD pips
+             * @example 5100
+             */
+            entry_price_usd_pips: string;
+            /**
+             * @description Notional in USD pips (10000 pips = $1)
+             * @example 500000
+             */
+            notional_amount_usd_pips: string;
+            /**
+             * @description Notional in USDC units (1,000,000 = 1 USDC)
+             * @example 50000000
+             */
+            notional_usdc_units: string;
+            /**
+             * @description Collateral in USDC units
+             * @example 25000000
+             */
+            collateral_usdc_units: string;
+            /**
+             * @description Combined origination fee in basis points
+             * @example 200
+             */
+            origination_fee_bps: number;
+            /**
+             * @description Origination fee in USDC units
+             * @example 1000000
+             */
+            origination_fee_usdc_units: string;
+            /**
+             * @description Protocol component of the origination fee in basis points
+             * @example 200
+             */
+            protocol_origination_fee_bps: number;
+            /**
+             * @description Partner component of the origination fee in basis points
+             * @example 0
+             */
+            partner_origination_fee_bps: number;
+            /**
+             * @description Polymarket venue trading fee rate in basis points (`feeRateBps`).
+             * @example 0
+             */
+            polymarket_trading_fee_bps: number;
+            /**
+             * @description Partner Polymarket builder taker fee in basis points (flat percentage of notional).
+             * @example 0
+             */
+            partner_trading_fee_bps: number;
+            /**
+             * @description Expected venue trading fee in USDC units charged to open the position (protocol venue fee + partner builder fee), computed from notional and entry price.
+             * @example 2204118
+             */
+            expected_open_trading_fee_usdc_units: string;
+            /**
+             * @description Total amount the user must provide to open, in USDC units.
+             * @example 28204118
+             */
+            total_user_amount_usdc_units: string;
+            /**
+             * @description Deterministic at-entry liquidation price ESTIMATE in USD pips (10000 pips = $1): `entry * (L-1)/L * (1 + liquidationFeeBps/10000)`. This is a closed-form estimate; the binding offer uses a TWAP/inference-based price that may differ.
+             * @example 2629
+             */
+            estimated_liquidation_price_usd_pips: string;
+            /**
+             * @description Gross maximum gain in USDC units: full value on a win (settlement at $1) minus notional, before fees. Profit over principal; may be negative.
+             * @example 48039215
+             */
+            gross_max_gain_usdc_units: string;
+            /**
+             * @description Net maximum gain in USDC units: grossMaxGain minus the open trading fee and the origination fee. Assumes a win via settlement (no exit trading fee) and excludes lifetime fees, so it is an upper bound. May be negative.
+             * @example 44835097
+             */
+            net_max_gain_usdc_units: string;
+        };
         CustomerLimit: {
             /**
              * @description Total limit formatted as USD
@@ -477,6 +661,11 @@ interface components {
              * @example 50
              */
             effective_slippage_bps?: number | null;
+            /**
+             * @description Original position token units delivered when the position opened (1000000 units = 1 token). Unlike `current.positionTokenUnits` (the live, possibly partially-closed survivor), this is the fixed size credited at open and is the basis for the partial-close minimum. Null until the open fill is recorded on chain.
+             * @example 10000000
+             */
+            position_token_units?: string | null;
         };
         CustomerPositionFailure: {
             /**
@@ -539,6 +728,24 @@ interface components {
              */
             deferred_at: string;
         };
+        CustomerPendingOperation: {
+            /**
+             * @description The lifecycle operation currently in flight on this position. Present whenever the position is mid-operation (open, close, partial close, unwind, liquidate, or settle); null when the position is at rest. Note `status` stays `open` throughout a `partial_close`, so this is the only signal a slice is in flight after a reload.
+             * @enum {string}
+             */
+            type: "open" | "close" | "partial_close" | "unwind" | "liquidate" | "settle";
+            /**
+             * @description Sub-state of the operation: `requested` (submitted, not yet executing), `initiated` (executing on the venue), `pending` (tokens withdrawn, finalizing on chain), `awaiting_settlement` (a close deferred until the market settles). Null when the operation has no distinct phase.
+             * @example initiated
+             * @enum {string|null}
+             */
+            phase?: "requested" | "initiated" | "pending" | "awaiting_settlement" | null;
+            /**
+             * @description Token units involved in the in-flight operation (1000000 units = 1 token). For `partial_close` this is the slice being closed; for `close`/`liquidate` the units withdrawn; for the awaiting-settlement close the remaining tokens. Null when the operation carries no specific token amount.
+             * @example 5000000
+             */
+            token_units?: string | null;
+        };
         CustomerPositionCurrent: {
             /**
              * @description Current book-value leverage in basis points (20000 = 2x)
@@ -611,6 +818,16 @@ interface components {
              * @example 55000
              */
             notional_usd_pips: string;
+            /**
+             * @description Smallest partial-close slice the contract will accept right now, in token units (1000000 units = 1 token): `max(5 tokens, 20% of the original opened size)`. Null when the position is not partial-closeable (an operation is already in flight, the open fill isn't recorded yet, or the survivor is below the minimum).
+             * @example 5000000
+             */
+            min_partial_close_token_units?: string | null;
+            /**
+             * @description Largest partial-close slice allowed right now, in token units (1000000 units = 1 token): the full survivor size currently held (`positionTokenUnits`). Null when the position is not partial-closeable.
+             * @example 10000000
+             */
+            max_partial_close_token_units?: string | null;
             /**
              * @description Position token units held (1000000 units = 1 token)
              * @example 10000000
@@ -802,8 +1019,13 @@ interface components {
              * @example 7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU
              */
             wallet_address: string;
-            /** @description Details of a close request that could not complete and was deferred. Null unless the customer requested a close that is now waiting on market settlement to redeem the remaining tokens. */
+            /**
+             * @deprecated
+             * @description Deprecated — use `pendingOperation` (a deferred close now surfaces as `{ type: 'close', phase: 'awaiting_settlement' }`). Details of a close request that could not complete and was deferred. Null unless the customer requested a close that is now waiting on market settlement to redeem the remaining tokens.
+             */
             close_attempt?: components["schemas"]["CustomerCloseAttempt"] | null;
+            /** @description The lifecycle operation currently in flight on this position, or null when the position is at rest. Survives reload (unlike the ephemeral websocket events), so a UI can show that a close / partial close / unwind / settle is in progress after re-fetching REST. */
+            pending_operation?: components["schemas"]["CustomerPendingOperation"] | null;
         };
         CustomerPositionClosedFees: {
             /**
@@ -898,6 +1120,16 @@ interface components {
              * @example 0
              */
             collected_liquidation_fee_usd_pips: string;
+            /**
+             * @description Volume-weighted notional realized across all unwinds and the final close, formatted as USD. Null for reverted or cancelled positions.
+             * @example 5.25
+             */
+            exit_notional_usd?: string | null;
+            /**
+             * @description Exit notional in USD pips. Null for reverted or cancelled positions.
+             * @example 52500
+             */
+            exit_notional_usd_pips?: string | null;
             /**
              * @description Realized PnL net of all fees (origination + lifetime + liquidation + venue) as return on equity in basis points
              * @example 1700
@@ -1078,6 +1310,38 @@ interface components {
              */
             min_fill_bps?: number;
         };
+        CustomerOfferMaxGain: {
+            /**
+             * @description Gross max gain (profit before fees) formatted as USD
+             * @example 1.90
+             */
+            gross_max_gain_usd: string;
+            /**
+             * @description Gross max gain in USD pips (10000 pips = $1)
+             * @example 19000
+             */
+            gross_max_gain_usd_pips: string;
+            /**
+             * @description Gross max gain in USDC units (1,000,000 units = 1 USDC). May be negative.
+             * @example 1900000
+             */
+            gross_max_gain_usdc_units: string;
+            /**
+             * @description Net max gain (profit after fees) formatted as USD
+             * @example 1.40
+             */
+            net_max_gain_usd: string;
+            /**
+             * @description Net max gain in USD pips (10000 pips = $1)
+             * @example 14000
+             */
+            net_max_gain_usd_pips: string;
+            /**
+             * @description Net max gain in USDC units (1,000,000 units = 1 USDC). May be negative.
+             * @example 1400000
+             */
+            net_max_gain_usdc_units: string;
+        };
         CustomerOffer: {
             /**
              * @description Offer ID
@@ -1325,6 +1589,8 @@ interface components {
             min_fill_bps?: number;
             /** @description Base64-encoded Solana transaction (present for Solana markets only) */
             swap_transaction?: string;
+            /** @description Expected maximum gain on a win (profit over principal). Only present when the request includes `expand=max_gain`; omitted otherwise. Assumes settlement at $1.00 (no exit trading fee) and excludes time-based lifetime fees, so it is an upper bound. */
+            max_gain?: components["schemas"]["CustomerOfferMaxGain"];
             /**
              * @description Total amount user must provide formatted as USD
              * @example 2.73
@@ -1364,7 +1630,9 @@ interface MarketPolymarket {
     yesTokenId: string;
 }
 type OriginationTier = CamelizeKeys<Raw["CustomerOriginationTier"]>;
-type Offer = CamelizeKeys<Raw["CustomerOffer"]>;
+type Quote = CamelizeKeys<Raw["CustomerOffer"]>;
+/** @deprecated Use {@link Quote}. Back-compat alias; removed in a future major. */
+type Offer = Quote;
 type OpenPosition = CamelizeKeys<Raw["CustomerOpenPosition"]>;
 type ClosedPosition = CamelizeKeys<Raw["CustomerClosedPosition"]>;
 type Position = OpenPosition | ClosedPosition;
@@ -1377,22 +1645,38 @@ type PositionResult = CamelizeKeys<Raw["CustomerPositionResult"]>;
 type PositionTiming = CamelizeKeys<Raw["CustomerPositionTiming"]>;
 type PositionFailure = CamelizeKeys<Raw["CustomerPositionFailure"]>;
 type CloseAttempt = CamelizeKeys<Raw["CustomerCloseAttempt"]>;
+type PendingOperation = CamelizeKeys<Raw["CustomerPendingOperation"]>;
 type PositionUnwind = CamelizeKeys<Raw["CustomerPositionUnwind"]>;
 type PositionUnwindList = CamelizeKeys<Raw["CustomerPositionUnwindList"]>;
 type PositionTransactions = CamelizeKeys<Raw["PositionTransactions"]>;
 type ContractInfo = CamelizeKeys<Raw["CustomerContractInfo"]>;
 type CustomerLimit = CamelizeKeys<Raw["CustomerLimit"]>;
 type CreateTokenResult = CamelizeKeys<Raw["CreateTokenResult"]>;
-interface CreateOfferParams {
+type FeeRatesOriginationTier = CamelizeKeys<Raw["CustomerOriginationFeeTier"]>;
+type FeeRatesMarket = CamelizeKeys<Raw["CustomerFeeRatesMarket"]>;
+type FeeRates = CamelizeKeys<Raw["CustomerFeeRates"]>;
+type FeeReport = CamelizeKeys<Raw["CustomerFeeReport"]>;
+interface CreateQuoteParams {
     marketTicker: string;
     effectiveSide: "yes" | "no";
     leverageBps: number;
     notionalAmountUsdPips: string;
     slippageBps: number;
     pmProvider?: "polymarket" | "kalshi";
+    allowPartialFill?: boolean;
+    minFillBps?: number;
+}
+/** @deprecated Renamed to {@link CreateQuoteParams}. Kept as an alias for backward compatibility. */
+type CreateOfferParams = CreateQuoteParams;
+interface FeeReportParams {
+    marketTicker: string;
+    effectiveSide: "yes" | "no";
+    leverageBps: number;
+    notionalAmountUsdPips: string;
+    entryPriceUsdPips?: string;
 }
 declare function isOpenPosition(p: Position): p is OpenPosition;
 declare function isClosedPosition(p: Position): p is ClosedPosition;
 declare function leverageMaxBps(lev: MarketLeverage, side: "yes" | "no"): number;
 
-export { leverageMaxBps as A, type PositionTransactions as B, type CreateOfferParams as C, type MarketPolymarket as D, type Market as M, type Offer as O, type Position as P, type CamelizeKeys as a, type CloseAttempt as b, type ClosedPosition as c, type ContractInfo as d, type CreateTokenResult as e, type CustomerLimit as f, type MarketFees as g, type MarketLeverage as h, type MarketMaxLeveragePerNotional as i, type MarketPrices as j, type MarketSidedEligibility as k, type MarketSidedMaxLeveragePerNotional as l, type OpenPosition as m, type OriginationTier as n, type PositionClosedFees as o, type PositionCurrent as p, type PositionEntry as q, type PositionFailure as r, type PositionOpenFees as s, type PositionResult as t, type PositionRisk as u, type PositionTiming as v, type PositionUnwind as w, type PositionUnwindList as x, isClosedPosition as y, isOpenPosition as z };
+export { type PositionOpenFees as A, type PositionResult as B, type CreateQuoteParams as C, type PositionRisk as D, type PositionTiming as E, type FeeRates as F, type PositionUnwind as G, type PositionUnwindList as H, isClosedPosition as I, isOpenPosition as J, leverageMaxBps as K, type Market as M, type Offer as O, type Position as P, type Quote as Q, type MarketPolymarket as a, type MarketLeverage as b, type PositionTransactions as c, type ContractInfo as d, type CustomerLimit as e, type FeeReportParams as f, type FeeReport as g, type CamelizeKeys as h, type CloseAttempt as i, type ClosedPosition as j, type CreateOfferParams as k, type CreateTokenResult as l, type FeeRatesMarket as m, type FeeRatesOriginationTier as n, type MarketFees as o, type MarketMaxLeveragePerNotional as p, type MarketPrices as q, type MarketSidedEligibility as r, type MarketSidedMaxLeveragePerNotional as s, type OpenPosition as t, type OriginationTier as u, type PendingOperation as v, type PositionClosedFees as w, type PositionCurrent as x, type PositionEntry as y, type PositionFailure as z };