@stryke-xyz/premarket-sdk 1.2.0 → 1.2.1

package/dist/cjs/config/index.js

@@ -12,6 +12,9 @@ _export(exports, {
     get CHAIN_ID_TO_CHAIN () {
         return CHAIN_ID_TO_CHAIN;
     },
+    get COMMUNITY_MARKET_MANAGER () {
+        return COMMUNITY_MARKET_MANAGER;
+    },
     get ENTRY_POINT () {
         return ENTRY_POINT;
     },
@@ -124,11 +127,12 @@ var _obj3;
     decimals: 6
 });
 var _obj4;
-/** OptionMarketVault contract addresses by supported chain. */ var OPTION_MARKET_VAULT = (_obj4 = {}, _define_property(_obj4, _chains.anvil.id, "0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512"), _define_property(_obj4, _chains.arbitrum.id, "0xd07280a68bd53b83b6b25861016bed637b3024ed"), _define_property(_obj4, _chains1.megaETH.id, "0xD4Aa38D6Ee04A401Cd7067A66201f680CbD1E7E4"), _obj4);
+/** OptionMarketVault contract addresses by supported chain. */ var OPTION_MARKET_VAULT = (_obj4 = {}, _define_property(_obj4, _chains.anvil.id, "0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512"), _define_property(_obj4, _chains.arbitrum.id, "0xd07280a68bd53b83b6b25861016bed637b3024ed"), _define_property(_obj4, _chains1.megaETH.id, "0x8F210f019EA5AE7da6d4Bf0227CF53997390fAA5"), _obj4);
 var _obj5;
-/** Exchange contract addresses by supported chain. */ var EXCHANGE = (_obj5 = {}, _define_property(_obj5, _chains.anvil.id, "0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0"), _define_property(_obj5, _chains.arbitrum.id, "0x8e25cc9aed1131c54b176ef2f0a3a5593db1554b"), _define_property(_obj5, _chains1.megaETH.id, "0x26f5D84aA1E894B059040cE2aE8cbf772A20125f"), _obj5);
+/** Exchange contract addresses by supported chain. */ var EXCHANGE = (_obj5 = {}, _define_property(_obj5, _chains.anvil.id, "0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0"), _define_property(_obj5, _chains.arbitrum.id, "0x8e25cc9aed1131c54b176ef2f0a3a5593db1554b"), _define_property(_obj5, _chains1.megaETH.id, "0xD76DD568918Dd1c37BF88FD3498DbB28147b93f7"), _obj5);
 var _obj6;
-/** MarketsRegistry contract addresses on chains where the registry is deployed. */ var MARKETS_REGISTRY = (_obj6 = {}, _define_property(_obj6, _chains.anvil.id, "0x5FbDB2315678afecb367f032d93F642f64180aa3"), _define_property(_obj6, _chains1.megaETH.id, "0x1c5FFbaEBa3Ef9fB6C650a4FF364918Bce418675"), _obj6);
+/** MarketsRegistry contract addresses on chains where the registry is deployed. */ var MARKETS_REGISTRY = (_obj6 = {}, _define_property(_obj6, _chains.anvil.id, "0x5FbDB2315678afecb367f032d93F642f64180aa3"), _define_property(_obj6, _chains1.megaETH.id, "0xc018879Ad776D48dB00D8e42Ee67145D9B02f8bc"), _obj6);
+/** CommunityMarketManager contract addresses on chains where it is deployed. */ var COMMUNITY_MARKET_MANAGER = _define_property({}, _chains1.megaETH.id, "0x702efdacE3c278A13e8a1CC9b4161Cb8d8cFbcC9");
 var _obj7;
 /** ERC-4337 EntryPoint addresses used by Stryke smart accounts. */ var ENTRY_POINT = (_obj7 = {}, _define_property(_obj7, _chains.anvil.id, "0x09635F643e140090A9A8Dcd712eD6285858ceBef"), _define_property(_obj7, _chains.arbitrum.id, "0x0000000071727De22E5E9d8BAf0edAc6f37da032"), _define_property(_obj7, _chains1.megaETH.id, "0x09635F643e140090A9A8Dcd712eD6285858ceBef"), _obj7);
 var _obj8;

package/dist/cjs/exchange/README.md

@@ -0,0 +1,280 @@
+# Exchange Guide
+
+The `exchange` module is the trading core of the SDK. It models the native
+order format used by Stryke's `Exchange` contract, reproduces its EIP-712
+signing schema, mirrors the most important fee and crossing math, and encodes
+calldata for fills, matches, cancellation, and batching.
+
+For most trading integrations this is the first module to understand.
+
+## Source map
+
+- [`index.ts`](./index.ts) re-exports the public exchange surface
+- [`types.ts`](./types.ts) defines in-memory and transport-safe order types
+- [`order.ts`](./order.ts) builds and validates orders
+- [`eip712.ts`](./eip712.ts) defines the domain, typed data, hashing, and signer
+  recovery helpers
+- [`math.ts`](./math.ts) mirrors pricing, fee, and crossing math
+- [`exchange-contract.ts`](./exchange-contract.ts) encodes calldata for the
+  shipped `Exchange` ABI
+- [`errors.ts`](./errors.ts) decodes custom errors from core protocol ABIs
+
+## What this module is for
+
+In plain language:
+
+- it tells wallets exactly what they are signing
+- it gives resolvers and frontends a stable order shape
+- it lets backend and UI code compute prices and fill amounts the same way the
+  contract does
+- it builds transaction payloads without each consumer bundling its own ABI
+
+## Core order model
+
+The canonical in-memory order type is [`ExchangeOrder`](./types.ts). Every
+numeric field is a `bigint`, so callers do not lose precision between order
+construction and signature generation.
+
+```ts
+export interface ExchangeOrder {
+  salt: bigint;
+  nonce: bigint;
+  marketId: bigint;
+  makingAmount: bigint;
+  takingAmount: bigint;
+  deadline: bigint;
+  maker: Address;
+  receiver: Address;
+  tradeType: TradeType;
+  signatureType: SignatureType;
+  tokenId: bigint;
+}
+```
+
+Related public types:
+
+- `TradeType`
+  - `BUY = 0`
+  - `SELL = 1`
+- `SignatureType`
+  - `EIP712 = 0`
+  - `ERC1271 = 1`
+- `SerializedExchangeOrder`
+  - string-safe transport version for HTTP or persistence
+- `ExchangeOrderStatus`
+  - `{ isFilledOrCancelled, remaining }`
+- `SerializedExchangeOrderStatus`
+  - string-safe status payload
+- `MulticallResult`
+  - helper type for multicall consumers
+
+## Building orders
+
+`buildExchangeOrder` in [`order.ts`](./order.ts) normalizes an order before it
+is signed or serialized:
+
+- `salt` defaults to a random 96-bit-compatible value
+- `receiver` defaults to `maker`
+- `signatureType` defaults to `SignatureType.EIP712`
+- `makingAmount`, `takingAmount`, and `deadline` must all be positive
+
+```ts
+import {
+  SignatureType,
+  TradeType,
+  buildExchangeOrder,
+} from "@stryke-xyz/premarket-sdk";
+
+const order = buildExchangeOrder({
+  maker: "0x1111111111111111111111111111111111111111",
+  nonce: 12n,
+  marketId: 7n,
+  makingAmount: 1_000_000n,
+  takingAmount: 500_000n,
+  deadline: 1_900_000_000n,
+  tradeType: TradeType.SELL,
+  signatureType: SignatureType.EIP712,
+  tokenId: 123456n,
+});
+```
+
+Public builder and validation helpers:
+
+- `buildExchangeOrder(params)`
+  - returns a normalized `ExchangeOrder`
+- `validateExchangeOrder(order)`
+  - enforces the minimal numeric invariants expected by the contract
+- `isOrderExpired(order, nowSec?)`
+  - compares `deadline` against a supplied or current unix timestamp
+- `getExecutableMakingAmount(order, status)`
+  - resolves the important status edge case where
+    `remaining === 0 && !isFilledOrCancelled` means the order is still fully
+    open
+- `getExchangeOrderHash(order, chainId, exchangeAddress)`
+  - convenience wrapper around the typed-data hashing helper
+
+## Signing and hashing
+
+The EIP-712 implementation in [`eip712.ts`](./eip712.ts) is the contract-aligned
+source of truth for signed order payloads.
+
+Important constants:
+
+- `EXCHANGE_EIP712_NAME = "Exchange"`
+- `EXCHANGE_EIP712_VERSION = "1"`
+- `EXCHANGE_ORDER_TYPES`
+  - the exact typed-data fields and enum serialization used in signatures
+
+Public helpers:
+
+- `getExchangeDomain(chainId, verifyingContract)`
+- `getExchangeTypedData(order, chainId, verifyingContract)`
+- `hashExchangeOrder(order, chainId, verifyingContract)`
+- `recoverExchangeOrderSigner(order, signature, chainId, verifyingContract)`
+
+```ts
+import {
+  getExchangeTypedData,
+  hashExchangeOrder,
+} from "@stryke-xyz/premarket-sdk";
+
+const typedData = getExchangeTypedData(order, 4326, exchangeAddress);
+const digest = hashExchangeOrder(order, 4326, exchangeAddress);
+```
+
+Use these helpers whenever you need exact parity with onchain signature checks.
+That includes CI, frontend signing, backend verification, and smart-account
+flows that still sign the native `Exchange` order shape.
+
+## Serialization helpers
+
+`serializeExchangeOrder` and `deserializeExchangeOrder` in [`types.ts`](./types.ts)
+bridge the two most common representations:
+
+- `ExchangeOrder` for local calculations and signing
+- `SerializedExchangeOrder` for APIs, storage, and JSON payloads
+
+Likewise, `serializeOrderStatus` and `deserializeOrderStatus` make it safe to
+transport status objects without losing `bigint` precision.
+
+## Math helpers
+
+[`math.ts`](./math.ts) contains the SDK's exchange-side arithmetic helpers.
+These are intentionally small, deterministic, and contract-aligned.
+
+Public constants:
+
+- `EXCHANGE_ONE = 10n ** 18n`
+- `FEE_RATE_BASE = 1_000_000n`
+
+Public math functions:
+
+- `getTakingAmount(fillMakingAmount, orderMakingAmount, orderTakingAmount)`
+  - floor division from maker-side fill amount to taker-side fill amount
+- `getMakingAmount(fillTakingAmount, orderMakingAmount, orderTakingAmount)`
+  - inverse of the above, also using floor division
+- `calculateFee(grossAmount, feeRate)`
+  - validates `feeRate` is within `[0, 1e6]`
+- `applyFee(grossAmount, feeRate)`
+  - returns `{ fee, net }`
+- `getOrderPriceWad(order)`
+  - normalizes price into 1e18 precision
+- `optionPrmToPrmId(tokenId)`
+  - canonicalizes `oPRM` token ids to the underlying even `PRM` id
+- `isCrossing(orderA, orderB)`
+  - detects valid crosses for complementary trades and mint/merge style matches
+- `hasValidTokenPairForMatch(orderA, orderB)`
+  - enforces token pairing rules for cross, mint, and merge cases
+
+```ts
+import {
+  applyFee,
+  getTakingAmount,
+  isCrossing,
+} from "@stryke-xyz/premarket-sdk";
+
+const takingAmount = getTakingAmount(250_000n, order.makingAmount, order.takingAmount);
+const { fee, net } = applyFee(takingAmount, 2_000n);
+const crossing = isCrossing(buyOrder, sellOrder);
+```
+
+## Calldata builders
+
+`ExchangeContract` in [`exchange-contract.ts`](./exchange-contract.ts) wraps the
+shipped ABI and returns either raw calldata or a minimal transaction envelope.
+
+```ts
+import { ExchangeContract } from "@stryke-xyz/premarket-sdk";
+
+const exchange = new ExchangeContract(exchangeAddress);
+
+const fillTx = exchange.buildFillOrderTx(order, 500_000n, signature);
+const matchData = exchange.getMatchOrderCalldata(
+  takerOrder,
+  takerSignature,
+  makerOrder,
+  makerSignature,
+  100_000n,
+  100_000n,
+);
+```
+
+Public methods:
+
+- `getFillOrderCalldata(order, fillAmount, signature)`
+- `buildFillOrderTx(order, fillAmount, signature)`
+- `getMatchOrderCalldata(takerOrder, takerSignature, makerOrder, makerSignature, takerFillAmount, makerFillAmount)`
+- `buildMatchOrderTx(takerOrder, takerSignature, makerOrder, makerSignature, takerFillAmount, makerFillAmount)`
+- `getCancelOrderCalldata(order)`
+- `getIncrementNonceCalldata()`
+- `getSetResolverWhitelistCalldata(resolver, isWhitelisted)`
+- `getSetFeeReceiverCalldata(newFeeReceiver)`
+- `getPauseCalldata()`
+- `getUnpauseCalldata()`
+- `getMulticallCalldata(data, allowFailure?)`
+
+`buildFillOrderTx` and `buildMatchOrderTx` are the only helpers that currently
+return a full `{ to, data, value }` transaction object. The remaining methods
+return encoded calldata so the caller can place them inside a broader tx or
+user operation.
+
+Restricted/admin surfaces:
+
+- `getSetResolverWhitelistCalldata`
+- `getSetFeeReceiverCalldata`
+- `getPauseCalldata`
+- `getUnpauseCalldata`
+
+These are documented here because they are part of the export surface, but they
+are operationally restricted and should not be treated as general-user flows.
+
+## Error decoding
+
+`decodeContractError` in [`errors.ts`](./errors.ts) attempts to decode a revert
+payload against the shipped `Exchange`, `OptionMarketVault`, and
+`MarketsRegistry` ABIs.
+
+It returns either `null` or:
+
+```ts
+interface DecodedContractError {
+  contract: "exchange" | "optionMarketVault" | "marketsRegistry";
+  name: string;
+  signature: string;
+  args: readonly unknown[];
+}
+```
+
+This is useful for frontend error messaging, backend diagnostics, and test
+assertions where raw revert bytes are not enough.
+
+## Recommended integration pattern
+
+1. Build a normalized order with `buildExchangeOrder` or `OrderHelper`.
+2. Hash or sign using the typed-data helpers.
+3. Serialize the order before sending it to the API.
+4. Use `ExchangeContract` to build fill or match calldata.
+5. Use `decodeContractError` when surfacing or logging contract reverts.
+
+If you want the higher-level workflow wrapper that bundles these steps together,
+continue with the [API guide](../api/README.md), which documents `OrderHelper`.

package/dist/cjs/package.json

@@ -1 +1 @@
-{"name":"@stryke-xyz/premarket-sdk","version":"1.2.0","type":"commonjs"}
+{"name":"@stryke-xyz/premarket-sdk","version":"1.1.8","type":"commonjs"}

package/dist/cjs/registry/README.md

@@ -0,0 +1,150 @@
+# Registry Guide
+
+The `registry` module wraps the `MarketsRegistry` contract surface that the SDK
+needs for market configuration and market serialization. It is intentionally
+small: the goal is to keep market definitions consistent across contracts,
+backend services, and frontend consumers.
+
+## Source map
+
+- [`index.ts`](./index.ts) re-exports the public registry surface
+- [`types.ts`](./types.ts) defines market structs and serializers
+- [`markets-registry-contract.ts`](./markets-registry-contract.ts) encodes
+  `MarketsRegistry` calldata
+
+## What this module is for
+
+In plain language:
+
+- it describes the market configuration shape used across the system
+- it converts that shape between `bigint` form and string-safe transport form
+- it encodes the registry's live write surface without each consumer shipping
+  its own ABI wrapper
+
+## Market types
+
+[`types.ts`](./types.ts) exports the registry's main data model:
+
+- `MarketType`
+  - `ERC20xERC20`
+  - `ERC20xERC6909`
+- `RegistryMarket`
+  - bigint-based market definition used in code
+- `SerializedRegistryMarket`
+  - string-safe market definition for JSON payloads and config files
+
+Core fields include:
+
+- token addresses: `underlying`, `collateral`, `delivery`, `owner`
+- sizing and strike metadata: `tickSize`, `tickSpacing`, `tokensPerTickSize`
+- expiry and fee fields: `expiry`, `depositFeeBps`, `redeemFeeBps`,
+  `makerFeeBps`, `takerFeeBps`, `rolloverFeeBps`
+- runtime flags: `marketType`, `isCollateralScaled`, `nonRollable`
+
+Serialization helpers:
+
+- `serializeRegistryMarket(market)`
+- `deserializeRegistryMarket(market)`
+
+```ts
+import {
+  MarketType,
+  serializeRegistryMarket,
+} from "@stryke-xyz/premarket-sdk";
+
+const market = serializeRegistryMarket({
+  underlying: "0x1111111111111111111111111111111111111111",
+  collateral: "0x2222222222222222222222222222222222222222",
+  delivery: "0x3333333333333333333333333333333333333333",
+  owner: "0x4444444444444444444444444444444444444444",
+  tickSize: 100n,
+  tickSpacing: 100n,
+  tokensPerTickSize: 1_000_000n,
+  expiry: 1_900_000_000n,
+  depositFeeBps: 0n,
+  redeemFeeBps: 0n,
+  makerFeeBps: 2_000n,
+  takerFeeBps: 2_000n,
+  rolloverFeeBps: 0n,
+  marketType: MarketType.ERC20xERC6909,
+  isCollateralScaled: false,
+  nonRollable: false,
+});
+```
+
+## Contract wrapper
+
+`MarketsRegistryContract` in
+[`markets-registry-contract.ts`](./markets-registry-contract.ts) wraps the
+shipped registry ABI and returns either calldata or a minimal tx envelope.
+
+```ts
+import {
+  MarketType,
+  MarketsRegistryContract,
+} from "@stryke-xyz/premarket-sdk";
+
+const registry = new MarketsRegistryContract(registryAddress);
+
+const tx = registry.buildAddMarketTx({
+  underlying: "0x1111111111111111111111111111111111111111",
+  collateral: "0x2222222222222222222222222222222222222222",
+  delivery: "0x3333333333333333333333333333333333333333",
+  owner: "0x4444444444444444444444444444444444444444",
+  tickSize: 100n,
+  tickSpacing: 100n,
+  tokensPerTickSize: 1_000_000n,
+  expiry: 1_900_000_000n,
+  depositFeeBps: 0n,
+  redeemFeeBps: 0n,
+  makerFeeBps: 2_000n,
+  takerFeeBps: 2_000n,
+  rolloverFeeBps: 0n,
+  marketType: MarketType.ERC20xERC6909,
+  isCollateralScaled: false,
+  nonRollable: false,
+});
+```
+
+Public surfaces:
+
+- `RegistryTransactionCall`
+  - `{ to, value?, data }`
+- `MarketsRegistryContract`
+  - `getAddMarketCalldata(market)`
+  - `buildAddMarketTx(market)`
+  - `getUpdateTokenCalldata(token, isStable, isDelete)`
+  - `getSetWhitelistedCalldata(account, allowed)`
+  - `getUpdateMarketExpiryCalldata(marketId, expiry)`
+  - `getMulticallCalldata(data)`
+
+Important nuance:
+
+- only `buildAddMarketTx` currently returns a full transaction object
+- the remaining helpers return raw calldata, which is often what relayers,
+  deployment scripts, or admin consoles actually want
+
+## Restricted surfaces
+
+Most registry writes are administrative by nature. The SDK documents them
+because they are exported and useful to privileged tooling, but they should not
+be treated as ordinary end-user operations:
+
+- `getAddMarketCalldata`
+- `buildAddMarketTx`
+- `getUpdateTokenCalldata`
+- `getSetWhitelistedCalldata`
+- `getUpdateMarketExpiryCalldata`
+- `getMulticallCalldata`
+
+## How this module fits with the rest of the SDK
+
+- the [Vault guide](../vault/README.md) uses registry-aligned market fields for
+  collateral and settlement math
+- the [Config guide](../config/README.md) ships deployed registry addresses
+- the [API guide](../api/README.md) returns market DTOs that map naturally back
+  to `RegistryMarket`-style concepts
+
+When protocol market semantics change, this module is one of the first places
+that should be updated, because downstream consumers assume it represents the
+canonical market shape.

package/dist/cjs/registry/markets-registry-contract.js

@@ -49,6 +49,7 @@ function _interop_require_default(obj) {
 }
 var marketsRegistryAbi = _MarketsRegistryabijson.default;
 /** Minimal transaction envelope returned by registry calldata builders. */ function normalizeMarket(market) {
+    var _market_isSpread, _market_useAbsoluteSpreadCollateral;
     return {
         underlying: market.underlying,
         collateral: market.collateral,
@@ -65,7 +66,9 @@ var marketsRegistryAbi = _MarketsRegistryabijson.default;
         rolloverFeeBps: BigInt(market.rolloverFeeBps),
         marketType: Number(market.marketType),
         isCollateralScaled: market.isCollateralScaled,
-        nonRollable: market.nonRollable
+        nonRollable: market.nonRollable,
+        isSpread: (_market_isSpread = market.isSpread) !== null && _market_isSpread !== void 0 ? _market_isSpread : false,
+        useAbsoluteSpreadCollateral: (_market_useAbsoluteSpreadCollateral = market.useAbsoluteSpreadCollateral) !== null && _market_useAbsoluteSpreadCollateral !== void 0 ? _market_useAbsoluteSpreadCollateral : false
     };
 }
 /** Calldata and transaction helpers for the markets registry contract. */ var MarketsRegistryContract = /*#__PURE__*/ function() {

package/dist/cjs/registry/types.js

@@ -41,7 +41,9 @@ _export(exports, {
         rolloverFeeBps: market.rolloverFeeBps.toString(),
         marketType: Number(market.marketType),
         isCollateralScaled: market.isCollateralScaled,
-        nonRollable: market.nonRollable
+        nonRollable: market.nonRollable,
+        isSpread: market.isSpread,
+        useAbsoluteSpreadCollateral: market.useAbsoluteSpreadCollateral
     };
 }
 /** Restores bigint fee and sizing fields from a serialized market payload. */ function deserializeRegistryMarket(market) {
@@ -61,6 +63,8 @@ _export(exports, {
         rolloverFeeBps: BigInt(market.rolloverFeeBps),
         marketType: market.marketType,
         isCollateralScaled: market.isCollateralScaled,
-        nonRollable: market.nonRollable
+        nonRollable: market.nonRollable,
+        isSpread: market.isSpread,
+        useAbsoluteSpreadCollateral: market.useAbsoluteSpreadCollateral
     };
 }