@splitmarkets/sdk 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,527 @@
+import { WalletClient, Address, Hex, PublicClient } from 'viem';
+
+declare const BASE_CHAIN_ID = 8453;
+declare const ARB_CHAIN_ID = 42161;
+declare const FACILITATOR_URL_BASE = "https://bundlerfix---b402-facilitator-base-posmj54s5q-uc.a.run.app";
+declare const FACILITATOR_URL_ARB = "https://b402-facilitator-arb-62092339396.us-central1.run.app";
+/** Facilitator base URL for a chain. */
+declare function facilitatorUrlForChain(chain: ChainName): string;
+declare const NEXUS_FACTORY: Address;
+declare const NEXUS_BOOTSTRAP: Address;
+interface UserOp {
+    sender: string;
+    nonce: string;
+    factory?: string;
+    factoryData?: string;
+    callData: string;
+    callGasLimit: string;
+    verificationGasLimit: string;
+    preVerificationGas: string;
+    maxFeePerGas: string;
+    maxPriorityFeePerGas: string;
+    paymaster?: string;
+    paymasterVerificationGasLimit?: string;
+    paymasterPostOpGasLimit?: string;
+    paymasterData?: string;
+    signature: string;
+}
+interface ExecuteCall {
+    to: Address;
+    data: Hex;
+    value: string;
+}
+/**
+ * Derive the deterministic Nexus smart-wallet address for an owner EOA on a chain.
+ * salt = keccak256("b402-"+reversed(owner)); computeAccountAddress(initData, salt).
+ * Counterfactual — works before the account is deployed (the first UserOp deploys it).
+ */
+declare function deriveSmartWallet(owner: Address, chain: ChainName, rpcUrl?: string): Promise<{
+    smartWallet: Address;
+    salt: string;
+}>;
+interface TradingAccount {
+    /** The user's connected EOA (funds source). */
+    eoa: Address;
+    /** The in-memory incognito EOA — owner of the smart wallet (never prompts to sign). */
+    incognitoEOA: Address;
+    /** The trading account: the b402 master Nexus smart wallet of the incognito EOA. */
+    smartWallet: Address;
+    /** Master salt of the incognito EOA (for the counterfactual first-UserOp deploy). */
+    salt: string;
+    /** SILENT UserOp-hash signer (the in-memory incognito key). */
+    signUserOpHash: (userOpHash: Hex) => Promise<Hex>;
+}
+/**
+ * Derive the user's trading account from ONE fixed-message signature (cached).
+ *
+ * The returned `smartWallet` is byte-identical to split.markets for the same EOA.
+ * Subsequent calls cost zero popups (the signature is cached in memory, and in
+ * sessionStorage in the browser under the same key split.markets uses).
+ */
+declare function deriveTradingAccount(walletClient: WalletClient, account: Address, chain?: ChainName, rpcUrl?: string): Promise<TradingAccount>;
+interface GaslessResult {
+    txHash: Hex;
+    userOpHash: Hex;
+}
+interface BuyGaslessArgs {
+    chain: ChainName;
+    side: Side;
+    seriesId: number;
+    /** Contracts to buy (human, e.g. 0.5). */
+    qN: number;
+    /** The user's connected wallet (signs the EIP-3009 pull, if any). */
+    walletClient: WalletClient;
+    /** The user's connected EOA (funds source). */
+    account: Address;
+    /** Pre-derived trading account (else derived from ONE cached signature). */
+    trading?: TradingAccount;
+    /** Pre-fetched quote (else fetched fresh right before the trade). */
+    quote?: SplitQuote;
+    /** Extra slippage over cost+fee, in bps (default 100 = 1%). */
+    slippageBps?: number;
+    facilitatorUrl?: string;
+    rpcUrl?: string;
+    /** Quote API base URL override. */
+    apiUrl?: string;
+}
+/**
+ * Open a position gaslessly. ZERO approval popups; gas sponsored. N mints to the
+ * TRADING ACCOUNT (smart wallet).
+ *
+ * Spends the trading account's USDC first and pulls ONLY the shortfall from the
+ * user's wallet via a single EIP-3009 signature — so it's 0 popups when the trading
+ * account is funded, at most 1 when short. The incognito key signs the UserOp silently.
+ */
+declare function buyGasless(args: BuyGaslessArgs): Promise<GaslessResult>;
+interface CloseGaslessArgs {
+    chain: ChainName;
+    side: Side;
+    seriesId: number;
+    /** Contracts to close (human). Defaults to the trading account's full N balance. */
+    qN?: number;
+    walletClient: WalletClient;
+    account: Address;
+    trading?: TradingAccount;
+    quote?: SplitQuote;
+    /** Min-proceeds slippage below the quoted bid, in bps (default 100 = 1%). */
+    slippageBps?: number;
+    facilitatorUrl?: string;
+    rpcUrl?: string;
+    apiUrl?: string;
+}
+/**
+ * Close a position gaslessly (sell N back to the pool). ZERO wallet popups — the N
+ * lives in the trading account, so the incognito key signs the UserOp silently and
+ * the user signs nothing. USDC proceeds settle in the trading account.
+ */
+declare function closeGasless(args: CloseGaslessArgs): Promise<GaslessResult>;
+interface PositionGaslessArgs {
+    chain: ChainName;
+    side: Side;
+    seriesId: number;
+    walletClient: WalletClient;
+    account: Address;
+    trading?: TradingAccount;
+    rpcUrl?: string;
+    apiUrl?: string;
+}
+interface GaslessPosition {
+    /** The trading account (smart wallet) the N is held in. */
+    smartWallet: Address;
+    qN: number;
+    markUsd: number;
+    intrinsicUsd: number;
+}
+/**
+ * Read the account's gasless position — the N held by the TRADING ACCOUNT (smart
+ * wallet) for one series. Mark is at MID = (ask+bid)/2; intrinsicUsd is the
+ * settlement floor (call: max(0, spot−strike)·N; put: max(0, strike−spot)·N).
+ */
+declare function getPositionGasless(args: PositionGaslessArgs): Promise<GaslessPosition>;
+
+declare const QUOTE_API = "https://quote-api-production-b5b9.up.railway.app";
+type ChainId = 8453 | 42161;
+type ChainName = "base" | "arbitrum";
+type Side = "long" | "short";
+interface ChainConfig {
+    id: ChainId;
+    name: ChainName;
+    /** SplitPool — long calls. */
+    splitPool: Address;
+    /** SplitPoolPut — short puts. "" when not deployed on this chain. */
+    splitPoolPut: Address | "";
+    weth: Address;
+    usdc: Address;
+    /** A public RPC; override per call via getPublic(chain, rpcUrl) if you have your own. */
+    rpc: string;
+}
+declare const CHAINS: Record<ChainName, ChainConfig>;
+/** The pool address for a chain + side. Throws if that side isn't deployed there. */
+declare function poolAddress(chain: ChainName, side: Side): Address;
+declare const SPLIT_POOL_ABI: readonly [{
+    readonly name: "epoch";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "phase";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint8";
+    }];
+}, {
+    readonly name: "seriesCount";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "epoch";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "seriesAt";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "epoch";
+    }, {
+        readonly type: "uint256";
+        readonly name: "id";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "address";
+        readonly name: "vault";
+    }, {
+        readonly type: "uint256";
+        readonly name: "strike";
+    }];
+}, {
+    readonly name: "freeWeth";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "freeUsdc";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "spot6";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "feeBps";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint16";
+    }];
+}, {
+    readonly name: "costWithFee";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "qN";
+    }, {
+        readonly type: "uint256";
+        readonly name: "askPerN";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "buyN";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "seriesId";
+    }, {
+        readonly type: "uint256";
+        readonly name: "qN";
+    }, {
+        readonly type: "uint256";
+        readonly name: "maxCost";
+    }, {
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly type: "address";
+        }, {
+            readonly type: "uint256";
+        }, {
+            readonly type: "uint256";
+        }, {
+            readonly type: "uint256";
+        }, {
+            readonly type: "uint256";
+        }];
+        readonly name: "q";
+    }, {
+        readonly type: "bytes";
+        readonly name: "sig";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "sellN";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "seriesId";
+    }, {
+        readonly type: "uint256";
+        readonly name: "qN";
+    }, {
+        readonly type: "uint256";
+        readonly name: "minProceeds";
+    }, {
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly type: "address";
+        }, {
+            readonly type: "uint256";
+        }, {
+            readonly type: "uint256";
+        }, {
+            readonly type: "uint256";
+        }, {
+            readonly type: "uint256";
+        }];
+        readonly name: "q";
+    }, {
+        readonly type: "bytes";
+        readonly name: "sig";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}];
+declare const SPLIT_VAULT_ABI: readonly [{
+    readonly name: "strike";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "maturity";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "exerciseEnd";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "settled";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly name: "N";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}];
+declare const ERC20_ABI: readonly [{
+    readonly name: "balanceOf";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "approve";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "spender";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly name: "allowance";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "owner";
+    }, {
+        readonly type: "address";
+        readonly name: "spender";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}];
+interface Greeks {
+    delta: number;
+    gamma: number;
+    theta_per_day: number;
+    vega: number;
+    iv: number;
+    spreadBps: number;
+}
+/** The pricer-signed quote, exactly as the quote API returns it. The 5-field tuple
+ *  [vault, askPerN, bidPerN, validUntil, nonce] + `signature` ride into buyN/sellN. */
+interface SplitQuote {
+    desk: Address;
+    vault: Address;
+    seriesId: number;
+    epoch?: number;
+    kind?: "call" | "put";
+    domainName?: string;
+    askPerN: string;
+    bidPerN: string;
+    validUntil: number;
+    nonce: string;
+    signature: Hex;
+    spot6?: string;
+    strike6?: string;
+    greeks?: Greeks;
+}
+interface Market {
+    seriesId: number;
+    vault: Address;
+    strike: number;
+    leverage: number;
+    spot: number;
+    premium: number;
+    label: string;
+    side: Side;
+}
+interface Position {
+    qN: number;
+    markUsd: number;
+    intrinsicUsd: number;
+}
+interface TradeResult {
+    txHash: Hex;
+    /** N minted (buy) or sold (close), in human contracts. */
+    qN: number;
+}
+/** A cached viem public client for a chain. Pass `rpcUrl` to use your own RPC. */
+declare function getPublic(chain: ChainName, rpcUrl?: string): PublicClient;
+/**
+ * Read the live grid: current epoch -> every series (seriesAt) -> strike + a quote.
+ * Leverage = spot / premium (the ask from the quote API). Returns [] if the pool
+ * isn't Trading or has no series. Never throws on a single bad series — it's skipped.
+ */
+declare function getMarkets(chain: ChainName, side: Side, rpcUrl?: string): Promise<Market[]>;
+/**
+ * GET /pool-quote?pool=&series=&put=0|1 from the hosted API. The signed quote is
+ * valid for ~3 min — fetch it RIGHT BEFORE a trade. The returned tuple + signature
+ * are carried verbatim into buyN/sellN; nothing here re-signs.
+ */
+declare function getQuote(chain: ChainName, side: Side, seriesId: number, apiUrl?: string): Promise<SplitQuote>;
+/** The 5-field, vault-first on-chain Quote tuple from a SplitQuote. */
+declare function quoteTuple(q: SplitQuote): readonly [Address, bigint, bigint, bigint, bigint];
+interface BuyArgs {
+    chain: ChainName;
+    side: Side;
+    seriesId: number;
+    /** Contracts to buy (human, e.g. 0.5). */
+    qN: number;
+    walletClient: WalletClient;
+    account: Address;
+    /** Override the RPC used for reads. */
+    rpcUrl?: string;
+    /** Pre-fetched quote (else one is fetched fresh). */
+    quote?: SplitQuote;
+    /** Extra slippage allowance over cost+fee, in bps (default 100 = 1%). */
+    slippageBps?: number;
+}
+/**
+ * Open a position with the connected wallet (two txs: approve USDC, then buyN).
+ *
+ *   1. fetch a fresh signed ask quote
+ *   2. compute maxCost = cost + fee + slippage (mirrors costWithFee, ceil-rounded)
+ *   3. approve USDC -> pool (exact maxCost, if allowance short)
+ *   4. pool.buyN(seriesId, qN, maxCost, quoteTuple, sig) -> N mints to the wallet
+ *
+ * Returns the buyN tx hash + the N minted. Max loss is the premium; no liquidation.
+ */
+declare function buy(args: BuyArgs): Promise<TradeResult>;
+interface CloseArgs {
+    chain: ChainName;
+    side: Side;
+    seriesId: number;
+    /** Contracts to close (human). Defaults to the full balance if omitted. */
+    qN?: number;
+    walletClient: WalletClient;
+    account: Address;
+    rpcUrl?: string;
+    quote?: SplitQuote;
+    /** Min-proceeds slippage tolerance below the quoted bid, in bps (default 100 = 1%). */
+    slippageBps?: number;
+}
+/**
+ * Close (sell N back to the pool) with the connected wallet (approve N, then sellN).
+ *
+ *   1. fetch a fresh signed bid quote
+ *   2. resolve the N token + your balance (close the full balance if qN omitted)
+ *   3. minProceeds = (proceeds - fee) - slippage
+ *   4. approve N -> pool (if allowance short)
+ *   5. pool.sellN(seriesId, qN, minProceeds, quoteTuple, sig) -> USDC to the wallet
+ */
+declare function close(args: CloseArgs): Promise<TradeResult>;
+interface PositionArgs {
+    chain: ChainName;
+    side: Side;
+    seriesId: number;
+    account: Address;
+    rpcUrl?: string;
+}
+/**
+ * Read the account's position in one series. Mark is at MID = (ask+bid)/2 — a fresh
+ * buy reads ≈ −(half-spread), not red by the full spread (this is the honest mark).
+ * intrinsicUsd is the settlement floor: a call is worth max(0, spot−strike)·N, a put
+ * max(0, strike−spot)·N. After expiry the pool stops bidding -> mark falls back to it.
+ */
+declare function getPosition(args: PositionArgs): Promise<Position>;
+
+export { ARB_CHAIN_ID, BASE_CHAIN_ID, type BuyArgs, type BuyGaslessArgs, CHAINS, type ChainConfig, type ChainId, type ChainName, type CloseArgs, type CloseGaslessArgs, ERC20_ABI, type ExecuteCall, FACILITATOR_URL_ARB, FACILITATOR_URL_BASE, type GaslessPosition, type GaslessResult, type Greeks, type Market, NEXUS_BOOTSTRAP, NEXUS_FACTORY, type Position, type PositionArgs, type PositionGaslessArgs, QUOTE_API, SPLIT_POOL_ABI, SPLIT_VAULT_ABI, type Side, type SplitQuote, type TradeResult, type TradingAccount, type UserOp, buy, buyGasless, close, closeGasless, deriveSmartWallet, deriveTradingAccount, facilitatorUrlForChain, getMarkets, getPosition, getPositionGasless, getPublic, getQuote, poolAddress, quoteTuple };

package/dist/index.js

@@ -0,0 +1 @@
+export { ARB_CHAIN_ID, BASE_CHAIN_ID, CHAINS, ERC20_ABI, FACILITATOR_URL_ARB, FACILITATOR_URL_BASE, NEXUS_BOOTSTRAP, NEXUS_FACTORY, QUOTE_API, SPLIT_POOL_ABI, SPLIT_VAULT_ABI, buy, buyGasless, close, closeGasless, deriveSmartWallet, deriveTradingAccount, facilitatorUrlForChain, getMarkets, getPosition, getPositionGasless, getPublic, getQuote, poolAddress, quoteTuple } from './chunk-MZEPXYHI.js';

package/dist/widget.d.ts

@@ -0,0 +1,43 @@
+import * as react from 'react';
+import { WalletClient, Address } from 'viem';
+import { ChainName } from './index.js';
+
+/** Brand overrides. Any omitted field falls back to the active theme preset. */
+interface SplitTradeWidgetAppearance {
+    /** Primary action / selection accent (buttons, focused tiles). */
+    accent?: string;
+    /** Widget background. */
+    background?: string;
+    /** Raised surfaces (inputs, position panel). */
+    surface?: string;
+    /** Primary text. */
+    text?: string;
+    /** Secondary / label text. */
+    muted?: string;
+    /** Corner radius for the card (inner controls scale from it). CSS length or number (px). */
+    radius?: string | number;
+    /** Font stack. */
+    fontFamily?: string;
+}
+/** Execution path. 'gasless' is reserved for the upcoming gasless-core; until it
+ *  lands the widget transparently runs 'connected'. */
+type SplitTradeWidgetMode = "gasless" | "connected";
+interface SplitTradeWidgetProps {
+    /** A connected viem WalletClient (e.g. from wagmi's useWalletClient). */
+    walletClient: WalletClient | null | undefined;
+    /** The connected account address. */
+    account: Address | null | undefined;
+    /** Which chain the wallet is on. Default "base". */
+    chain?: ChainName;
+    /** Base look. Defaults to "dark" (the original styling). */
+    theme?: "dark" | "light";
+    /** Per-token brand overrides layered on top of `theme`. */
+    appearance?: SplitTradeWidgetAppearance;
+    /** Extra class on the scoped root (for integrator CSS / utility classes). */
+    className?: string;
+    /** Execution path. Default "connected" (gasless arrives with gasless-core). */
+    mode?: SplitTradeWidgetMode;
+}
+declare function SplitTradeWidget({ walletClient, account, chain, theme, appearance, className, mode, }: SplitTradeWidgetProps): react.JSX.Element;
+
+export { SplitTradeWidget, type SplitTradeWidgetAppearance, type SplitTradeWidgetMode, type SplitTradeWidgetProps, SplitTradeWidget as default };