refactor: restructure Lighter SDK by removing deprecated Go files and enhancing Python documentation with new examples and models

chore: update referral links in README files for Lighter and Aster
feat: implement client ping/pong mechanism in LighterGateway for improved WebSocket connection health
2026-09-12 09:48:07 +00:00 · 2025-12-07 19:14:56 +08:00 · 2025-11-29 01:57:44 +08:00 · 2025-11-13 02:53:23 +08:00 · 2025-11-13 02:34:10 +08:00 · 2025-11-13 02:29:36 +08:00
372 changed files with 59616 additions and 4498 deletions
@@ -37,6 +37,22 @@ MAKER_REFRESH_INTERVAL_MS=500          # Maker refresh cadence (ms)
 MAKER_MAX_CLOSE_SLIPPAGE_PCT=0.05       # Maker close slippage guard (fallbacks to MAX_CLOSE_SLIPPAGE_PCT)
 MAKER_PRICE_TICK=0.1                    # Maker price tick size (defaults to PRICE_TICK)

+# Grid strategy defaults
+GRID_LOWER_PRICE=25000                  # Grid lower bound price (quote currency)
+GRID_UPPER_PRICE=35000                  # Grid upper bound price
+GRID_LEVELS=10                          # Number of grid levels between bounds (>=2)
+GRID_ORDER_SIZE=0.001                   # Quantity per grid order (base asset units)
+GRID_MAX_POSITION_SIZE=0.01             # Max inventory the grid may hold (base units)
+GRID_REFRESH_INTERVAL_MS=1000           # Grid evaluation cadence (ms)
+GRID_MAX_LOG_ENTRIES=200                # Grid trade log length (defaults to MAX_LOG_ENTRIES when unset)
+GRID_DIRECTION=both                     # Order direction: both | long | short
+GRID_STOP_LOSS_PCT=0.01                 # Stop loss trigger percentage beyond bounds (0.01 => 1%)
+GRID_RESTART_TRIGGER_PCT=0.01           # Restart buffer percentage inside bounds
+GRID_AUTO_RESTART_ENABLED=true          # Automatically resume grid when price re-enters range
+GRID_MAX_CLOSE_SLIPPAGE_PCT=0.05        # Close-order slippage guard relative to mark price
+# GRID_PRICE_TICK=0.1                   # Optional override for grid price tick (falls back to PRICE_TICK)
+# GRID_QTY_STEP=0.001                   # Optional override for grid quantity step (falls back to QTY_STEP)
+
 # GRVT authentication (set when EXCHANGE=grvt)
 GRVT_API_KEY=
 GRVT_API_SECRET=
@@ -83,12 +99,10 @@ BACKPACK_DEBUG=false
 # Provide the EVM private key & wallet address for onboarded accounts.
 # When EXCHANGE=paradex these values are used automatically.

+PARADEX_SYMBOL=BTC-USD-PERP
 PARADEX_PRIVATE_KEY=
 PARADEX_WALLET_ADDRESS=

-# Symbol defaults to TRADE_SYMBOL if omitted. Use ccxt unified format like BTC-USD-PERP.
-# PARADEX_SYMBOL=BTC-USD-PERP
-
 # Enable testnet endpoints by setting to "true"; defaults to false (mainnet).
 # PARADEX_SANDBOX=false

@@ -1,42 +1,62 @@
 # ritmex-bot

-基于 Bun 的 Aster 永续合约量化终端，内置趋势跟随（SMA30）与做市策略，支持快速恢复、实时行情订阅与日志追踪。
+基于 Bun 的多交易所永续合约量化终端，内置趋势跟随（SMA30）、Guardian 防守与做市策略，支持快速恢复、实时行情订阅、日志追踪与 CLI 仪表盘。

-* [Aster 30% 手续费优惠注册链接](https://www.asterdex.com/zh-CN/referral/4665f3)
+如果您希望获取优惠并支持本项目，请考虑使用以下注册链接：
+
+* [Lighter 手续费优惠注册链接](https://app.lighter.xyz/?referral=111909FA)
+* [Aster 手续费优惠注册链接](https://www.asterdex.com/zh-CN/referral/4665f3)
+* [Binance 手续费优惠注册链接](https://www.binance.com/join?ref=KNKCA9XC)
 * [GRVT 手续费优惠注册链接](https://grvt.io/exchange/sign-up?ref=sea)
+* [Backpack 手续费优惠注册链接](https://backpack.exchange/join/ritmex)
+* [edgex 手续费优惠注册链接](https://pro.edgex.exchange/referral/BULL)
+* [Paradex 手续费优惠注册链接](https://paradex.io/ref/xingxingjun)
+* [Apex 手续费优惠注册链接](https://join.omni.apex.exchange/SEA)

 ## 文档索引
 - [English README](README_en.md)
 - [简明上手指南（零基础）](simple-readme.md)
+- [基础网格策略使用教程](grid-trading.md)

-## 项目亮点
- **实时行情与风控**：Websocket + REST 自动同步账户、挂单与仓位。
+## 核心特性
+- **实时行情与风控**：Websocket + REST 自动同步账户、挂单与仓位，断线后自动恢复。
 - **趋势策略**：SMA30 穿越入场，内置止损、移动止盈、布林带带宽过滤与步进锁盈。
- **做市策略**：支持双边追价、风险阈值与订单自愈。
- **模块化设计**：适配器、策略引擎与 CLI 解耦，方便扩展新交易所或策略。
+- **Guardian 策略**：不主动开单，实时监听账户仓位并强制补挂/移动止损与动态止盈，防止裸奔。
+- **做市策略**：支持双边追价、风险阈值控制与订单自愈。
+- **模块化架构**：策略引擎、交易所适配器与 Ink CLI 相互解耦，新增交易所或策略更容易。

-## 环境要求
- Bun ≥ 1.2（含 `bun`、`bunx` 命令）
- macOS、Linux 或 Windows (WSL 推荐)
- Node.js 仅在某些安装路径需要，可选
+## 支持的交易所
+| 交易所 | 合约类型 | 必填环境变量 | 备注 |
+| --- | --- | --- | --- |
+| Aster | USDT 永续 | `ASTER_API_KEY`, `ASTER_API_SECRET` | 默认交易所；兼容脚本引导
+| GRVT | USDT 永续 | `GRVT_API_KEY`, `GRVT_API_SECRET`, `GRVT_SUB_ACCOUNT_ID` | `GRVT_ENV` 可切换 `prod`/`testnet`
+| Lighter | zkLighter 永续 | `LIGHTER_ACCOUNT_INDEX`, `LIGHTER_API_PRIVATE_KEY` | 默认 `LIGHTER_ENV=testnet`
+| Backpack | USDC 永续 | `BACKPACK_API_KEY`, `BACKPACK_API_SECRET`, `BACKPACK_PASSWORD` | `BACKPACK_SANDBOX=true` 启用沙盒
+| Paradex | StarkEx 永续 | `PARADEX_PRIVATE_KEY`, `PARADEX_WALLET_ADDRESS` | `PARADEX_SANDBOX=true` 使用测试网

-## 快速启动脚本（macOS / Linux / WSL）
+## 系统要求
+- Bun ≥ 1.2（需同时包含 `bun`、`bunx` 命令）
+- macOS、Linux 或 Windows (推荐 WSL)
+- Node.js 仅在部分工具链场景需要，可选
+
+## 快速上手
+### 一键脚本（macOS / Linux / WSL）
 ```bash
 curl -fsSL https://github.com/discountry/ritmex-bot/raw/refs/heads/main/setup.sh | bash
 ```
-脚本会安装 Bun、依赖，收集 Aster API Key/Secret，生成 `.env` 并启动 CLI。运行前请准备好 API 凭证。
+脚本会安装 Bun、项目依赖，收集 Aster API 凭证，生成 `.env` 并启动 CLI。运行前请准备好对应交易所的 API Key/Secret。

-## 手动安装步骤
+### 手动安装
 1. **获取代码**
   ```bash
   git clone https://github.com/discountry/ritmex-bot.git
   cd ritmex-bot
   ```
-   不方便使用 Git 时，可在仓库页面下载 ZIP 并手动解压。
+   不便使用 Git 时，可在仓库页面下载 ZIP 后手动解压。
 2. **安装 Bun**
   - macOS / Linux：`curl -fsSL https://bun.sh/install | bash`
   - Windows PowerShell：`powershell -c "irm bun.sh/install.ps1 | iex"`
-   安装后重新打开终端，确认 `bun -v` 正常输出版本号。
+   安装完成后重新打开终端，确认 `bun -v` 正常输出版本号。
 3. **安装依赖**
   ```bash
   bun install
@@ -45,67 +65,87 @@ curl -fsSL https://github.com/discountry/ritmex-bot/raw/refs/heads/main/setup.sh
   ```bash
   cp .env.example .env
   ```
-   按下文说明修改 `.env`，至少需要正确配置 Aster 或 GRVT 的 API。
+   按下文指南修改 `.env`，至少需要正确配置一个交易所的凭证。
 5. **运行 CLI**
   ```bash
   bun run index.ts
   ```
-   方向键选择策略，回车启动；`Esc` 返回菜单，`Ctrl+C` 退出。
+   方向键选择策略并回车启动；`Esc` 返回菜单，`Ctrl+C` 退出。

-## 环境变量配置指南
-核心变量在 `.env.example` 中给出默认值：
+## 通用环境变量
+`.env.example` 提供了所有默认键值，下表概括最常用参数：

 | 变量 | 说明 |
 | --- | --- |
-| `ASTER_API_KEY` / `ASTER_API_SECRET` | Aster API 凭证，运行策略必填 |
+| `EXCHANGE` | 选择交易所（`aster`/`grvt`/`lighter`/`backpack`/`paradex`） |
 | `TRADE_SYMBOL` | 交易对（默认 `BTCUSDT`） |
 | `TRADE_AMOUNT` | 单笔下单数量（标的资产计） |
 | `LOSS_LIMIT` | 单笔最大亏损触发的强平额度（USDT） |
 | `TRAILING_PROFIT` / `TRAILING_CALLBACK_RATE` | 动态止盈触发值（USDT）与回撤百分比 |
 | `PROFIT_LOCK_TRIGGER_USD` / `PROFIT_LOCK_OFFSET_USD` | 浮盈超过阈值后上调止损的触发金额与偏移 |
-| `BOLLINGER_LENGTH` / `BOLLINGER_STD_MULTIPLIER` | 布林带宽度判定的窗口长度与标准差倍数 |
-| `MIN_BOLLINGER_BANDWIDTH` | 仅当带宽 ≥ 此比例时才触发入场信号 |
+| `BOLLINGER_*` | 趋势策略布林带过滤参数 |
 | `PRICE_TICK` / `QTY_STEP` | 交易所要求的最小报价与数量精度 |
 | `POLL_INTERVAL_MS` | 趋势策略循环间隔（毫秒） |
 | `MAX_CLOSE_SLIPPAGE_PCT` | 平仓时相对标记价允许的最大偏差 |
-| `MAKER_*` 系列 | 做市策略独有参数（追价阈值、报价偏移、刷新频率等） |
+| `MAKER_*` | 做市策略专属参数（追价阈值、报价偏移、刷新频率等） |

-切换到 GRVT 时，将 `EXCHANGE=grvt` 并补齐 `GRVT_API_KEY`、`GRVT_API_SECRET`、`GRVT_SUB_ACCOUNT_ID` 等变量；详情见 `.env.example`。
-
-> 提示：你也可以通过命令行参数临时指定交易所（优先级高于环境变量）：
+> 可通过命令行临时覆盖交易所与策略（优先级高于 `.env`）：
 > ```bash
-> bun run index.ts --exchange grvt
-> bun run index.ts -e lighter
+> bun run index.ts --exchange grvt --strategy maker
+> bun run index.ts -e lighter -s offset-maker --silent
 > ```

-## 常用命令
+## 交易所配置指南
+### Aster
+1. 将 `EXCHANGE` 保持为 `aster`（默认值）。
+2. 填写 `ASTER_API_KEY` 与 `ASTER_API_SECRET`。
+3. 根据交易对调整 `TRADE_SYMBOL`、`PRICE_TICK`、`QTY_STEP` 等精度参数。
+4. 一键脚本会自动写入这些变量，手动部署时需自行维护。
+
+### GRVT
+1. 在 `.env` 中设置 `EXCHANGE=grvt`。
+2. 填写 `GRVT_API_KEY`、`GRVT_API_SECRET`、`GRVT_SUB_ACCOUNT_ID`。
+3. 若使用测试网，可将 `GRVT_ENV=testnet` 并调整 `GRVT_INSTRUMENT`/`GRVT_SYMBOL`。
+4. 可选：提供 `GRVT_COOKIE` 或自定义 `GRVT_SIGNER_PATH` 以复用已有登录态。
+
+### Lighter
+1. 设置 `EXCHANGE=lighter`。
+2. 填写 `LIGHTER_ACCOUNT_INDEX` 与 `LIGHTER_API_PRIVATE_KEY`（40 字节十六进制私钥），其中`LIGHTER_ACCOUNT_INDEX`是你的账户索引，需要你在官网按F12观察接口请求获取，`LIGHTER_API_PRIVATE_KEY`是你的API私钥。
+3. 如需切换环境，将 `LIGHTER_ENV` 改为 `mainnet`/`staging`/`dev`；必要时指定 `LIGHTER_BASE_URL`。
+4. 交易对默认为 `LIGHTER_SYMBOL=BTCUSDT`，也可按需重写价格与数量小数位。
+
+### Backpack
+1. 设置 `EXCHANGE=backpack`。
+2. 填写 `BACKPACK_API_KEY`、`BACKPACK_API_SECRET`、`BACKPACK_PASSWORD`；如有分账户，补充 `BACKPACK_SUBACCOUNT`，默认填写主账户ID。
+3. 使用测试环境时将 `BACKPACK_SANDBOX=true`，并确认 `BACKPACK_SYMBOL` 与实际符号一致（默认 `BTC_USD_PERP`）。
+4. 可通过 `BACKPACK_DEBUG=true` 观察适配器详细日志。
+
+### Paradex
+1. 设置 `EXCHANGE=paradex`。
+2. 提供 `PARADEX_PRIVATE_KEY`（EVM 私钥）与 `PARADEX_WALLET_ADDRESS` 注意这是你EVM钱包的地址和私钥，建议创建全新钱包，不要放置无关资产。
+3. 默认连接主网，若需测试网，将 `PARADEX_SANDBOX=true` 并根据需要调整 `PARADEX_SYMBOL`。
+4. 复杂环境可额外设置 `PARADEX_USE_PRO`、`PARADEX_RECONNECT_DELAY_MS` 或调试开关。
+
+## 命令速查
 ```bash
-bun run index.ts   # 启动 CLI（默认）
-bun run start      # 同上
-bun run dev        # 调试模式，等价于运行 index.ts
-bun x vitest run   # 执行单元测试
+bun run index.ts   # 启动 CLI（默认入口）
+bun run start      # 等价于运行 index.ts
+bun run dev        # 调试模式
+bun x vitest run   # 执行全部测试
 ```

 ## 静默启动与后台运行
 ### 直接静默启动
 无需进入 Ink 菜单，可用命令行直接拉起指定策略：
-
 ```bash
-bun run index.ts --strategy trend --silent        # 启动趋势策略
-bun run index.ts --strategy maker --silent        # 启动做市策略
-bun run index.ts --strategy offset-maker --silent # 启动偏移做市策略
-```
-
-如需同时指定交易所，可叠加 `--exchange/-e`（将覆盖 `.env` 中的 `EXCHANGE`/`TRADE_EXCHANGE`）：
-
-```bash
-bun run index.ts --exchange grvt --strategy maker --silent
-bun run index.ts -e lighter -s offset-maker --silent
+bun run index.ts --strategy trend --silent
+bun run index.ts --strategy maker --silent
+bun run index.ts --strategy offset-maker --silent
 ```
+如需同时指定交易所，可叠加 `--exchange/-e` 参数。

 ### 项目内置脚本
 `package.json` 提供了便捷脚本：
-
 ```bash
 bun run start:trend:silent
 bun run start:maker:silent
@@ -113,43 +153,38 @@ bun run start:offset:silent
 ```

 ### 使用 pm2 守护并自动重启
-将 `pm2` 安装到项目中（示例：`bun add -d pm2`），之后即可在不安装全局 pm2 的情况下运行：
-
+安装 `pm2`（示例：`bun add -d pm2`）后，可在项目内直接运行：
 ```bash
 bunx pm2 start bun --name ritmex-trend --cwd . --restart-delay 5000 -- run index.ts --strategy trend --silent
 ```
-
-亦可直接调用脚本：
-
+或调用预置脚本：
 ```bash
 bun run pm2:start:trend
 bun run pm2:start:maker
 bun run pm2:start:offset
 ```
-
-根据需要调整 `--name`、`--cwd`、`--restart-delay` 等参数，完成后可执行 `pm2 save` 持久化进程列表。
+完成配置后可执行 `pm2 save` 持久化进程列表。

 ## 测试
 项目使用 Vitest：
 ```bash
-bun run test        # 运行全部测试
+bun run test
 bun x vitest --watch
 ```

 ## 常见问题
-
- 你需要至少 50-100 USDT 的资金才能运行策略
- 请在交易所自行设置 50 倍左右的杠杆，本策略不包含杠杆设置
- 请确保你电脑/服务器的时间是准确的真实世界时间
- 持仓方式需要保持单向持仓
+- 至少准备 50–100 USDT 资金以覆盖策略运行需求。
+- 杠杆需在交易所提前设置（建议 ~50 倍），程序不会自动调整。
+- 请确保服务器/电脑时间同步真实世界时间，避免签名过期。
+- 账户需保持单向持仓模式。
 - `.env` 未读取：确认文件位于项目根目录且变量名无误。
 - API 拒绝访问：检查交易所后台权限，确保开启合约读写。
 - 精度错误：同步交易对的最小价格与数量步长。
-更多排查步骤可参考 [简明上手指南](simple-readme.md)。
+更多排查细节可参见 [简明上手指南](simple-readme.md)。

 ## 社区与支持
 - Telegram 交流群：[https://t.me/+4fdo0quY87o4Mjhh](https://t.me/+4fdo0quY87o4Mjhh)
- 反馈或新特性建议请提交 Issue 或 PR
+- 欢迎通过 Issue 或 PR 提交反馈、特性建议

 ## 风险提示
-量化交易具备风险。建议在仿真或小额账户中验证策略表现，妥善保管 API 密钥，仅开启必要权限。
+量化交易具备风险。请先在仿真或小额账户中验证策略表现，妥善保管 API 密钥，仅开启必要权限。
@@ -1,39 +1,59 @@
 # ritmex-bot

-A Bun-powered trading workstation for Aster perpetual contracts that ships two production-ready agents: an SMA30 trend follower and a dual-sided market maker. The CLI is built with Ink, synchronises risk state from the exchange, and automatically recovers from restarts or disconnects.
+A Bun-powered multi-exchange perpetuals workstation that ships an SMA30 trend engine, a Guardian stop sentinel, and two market-making modes. It offers instant restarts, realtime market data, structured logging, and an Ink-based CLI dashboard.
+
+* [Lighter referral link](https://app.lighter.xyz/?referral=111909FA)
+* [Aster referral link](https://www.asterdex.com/en/referral/4665f3)
+* [Binance referral link](https://www.binance.com/join?ref=KNKCA9XC)
+* [GRVT referral link](https://grvt.io/exchange/sign-up?ref=sea)
+* [Backpack referral link](https://backpack.exchange/join/ritmex)
+* [edgex referral link](https://pro.edgex.exchange/referral/BULL)
+* [Paradex referral link](https://paradex.io/ref/xingxingjun)
+* [Apex referral link](https://join.omni.apex.exchange/RITHMEX)

 ## Documentation Map
 - [中文 README](README.md)
 - [Beginner-friendly Quick Start](simple-readme.md)

 ## Highlights
- **Live market data & risk sync** via websocket feeds with REST fallbacks, full reconciliation on restart.
- **Trend engine** featuring SMA30 entries, fixed stop loss, trailing stop, Bollinger bandwidth gate, and profit-lock stepping.
- **Market-making loop** with adaptive quote chasing, loss caps, and automatic order healing.
- **Extensible architecture** decoupling exchange adapters, engines, and the Ink CLI for easy venue or strategy additions.
+- **Live data & risk sync** via websockets with REST fallbacks and full reconciliation on restart.
+- **Trend strategy** featuring SMA30 entries, fixed stop loss, trailing stop, Bollinger bandwidth gate, and profit-lock stepping.
+- **Guardian strategy** that never opens trades but mirrors your live exposure, ensuring every position has a synced stop loss and trailing stop.
+- **Market-making loop** with dual-sided quote chasing, loss caps, and automatic order healing.
+- **Modular architecture** decoupling engines, exchange adapters, and the Ink CLI for easy venue or strategy extensions.
+
+## Supported Exchanges
+| Exchange | Contract Type | Required Environment Variables | Notes |
+| --- | --- | --- | --- |
+| Aster | USDT perpetuals | `ASTER_API_KEY`, `ASTER_API_SECRET` | Default venue; works with the bootstrap script |
+| GRVT | USDT perpetuals | `GRVT_API_KEY`, `GRVT_API_SECRET`, `GRVT_SUB_ACCOUNT_ID` | Switch `GRVT_ENV` between `prod` and `testnet` |
+| Lighter | zkLighter perpetuals | `LIGHTER_ACCOUNT_INDEX`, `LIGHTER_API_PRIVATE_KEY` | Defaults to `LIGHTER_ENV=testnet` |
+| Backpack | USDC perpetuals | `BACKPACK_API_KEY`, `BACKPACK_API_SECRET`, `BACKPACK_PASSWORD` | Set `BACKPACK_SANDBOX=true` for the sandbox |
+| Paradex | StarkEx perpetuals | `PARADEX_PRIVATE_KEY`, `PARADEX_WALLET_ADDRESS` | Toggle `PARADEX_SANDBOX=true` for the testnet |

 ## Requirements
- Bun ≥ 1.2 (`bun`, `bunx` available on PATH)
+- Bun ≥ 1.2 (both `bun` and `bunx` on PATH)
 - macOS, Linux, or Windows via WSL (native Windows works but WSL is recommended)
- Node.js is optional unless your environment requires it for tooling
+- Node.js is optional unless your tooling requires it

-## One-Line Bootstrap (macOS / Linux / WSL)
+## Quick Start
+### One-line bootstrap (macOS / Linux / WSL)
 ```bash
 curl -fsSL https://github.com/discountry/ritmex-bot/raw/refs/heads/main/setup.sh | bash
 ```
-The script installs Bun, project dependencies, collects Aster API credentials, generates `.env`, and launches the CLI. Prepare your API Key/Secret before running.
+The script installs Bun, project dependencies, collects Aster API credentials, generates `.env`, and launches the CLI. Prepare the relevant exchange API keys before running it.

-## Manual Installation
+### Manual installation
 1. **Clone the repository**
   ```bash
   git clone https://github.com/discountry/ritmex-bot.git
   cd ritmex-bot
   ```
-   Alternatively download the ZIP from GitHub and extract it manually.
+   Alternatively, download the ZIP from GitHub and extract it manually.
 2. **Install Bun**
   - macOS / Linux: `curl -fsSL https://bun.sh/install | bash`
   - Windows PowerShell: `powershell -c "irm bun.sh/install.ps1 | iex"`
-   Re-open the terminal and confirm `bun -v` prints a version.
+   Re-open the terminal and verify `bun -v` prints a version.
 3. **Install dependencies**
   ```bash
   bun install
@@ -42,67 +62,87 @@ The script installs Bun, project dependencies, collects Aster API credentials, g
   ```bash
   cp .env.example .env
   ```
-   Edit `.env` with your exchange credentials and overrides.
+   Edit `.env` with the exchange credentials and overrides you plan to use.
 5. **Launch the CLI**
   ```bash
   bun run index.ts
   ```
-   Use the arrow keys to pick a strategy, `Enter` to start, `Esc` to return to the menu, and `Ctrl+C` to exit.
+   Use the arrow keys to pick a strategy, `Enter` to start, `Esc` to go back, and `Ctrl+C` to exit.

-## Environment Variables
-The most important settings shipped in `.env.example` are summarised below:
+## Shared Configuration
+`.env.example` captures all defaults; the most common settings are summarised below.

 | Variable | Purpose |
 | --- | --- |
-| `ASTER_API_KEY` / `ASTER_API_SECRET` | Required Aster exchange credentials |
-| `TRADE_SYMBOL` | Contract symbol, defaults to `BTCUSDT` |
+| `EXCHANGE` | Choose the venue (`aster` / `grvt` / `lighter` / `backpack` / `paradex`) |
+| `TRADE_SYMBOL` | Contract symbol (defaults to `BTCUSDT`) |
 | `TRADE_AMOUNT` | Order size in base asset units |
-| `LOSS_LIMIT` | Max per-trade loss (USDT) before forced close |
-| `TRAILING_PROFIT` / `TRAILING_CALLBACK_RATE` | Trailing stop trigger amount (USDT) and pullback percentage |
-| `PROFIT_LOCK_TRIGGER_USD` / `PROFIT_LOCK_OFFSET_USD` | Move the base stop once unrealised PnL exceeds this trigger |
-| `BOLLINGER_LENGTH` / `BOLLINGER_STD_MULTIPLIER` | Window size and std-dev multiplier for bandwidth filtering |
-| `MIN_BOLLINGER_BANDWIDTH` | Minimum bandwidth ratio required before opening a new position |
+| `LOSS_LIMIT` | Max per-trade loss in USDT before forced close |
+| `TRAILING_PROFIT` / `TRAILING_CALLBACK_RATE` | Trailing stop trigger (USDT) and pullback percentage |
+| `PROFIT_LOCK_TRIGGER_USD` / `PROFIT_LOCK_OFFSET_USD` | Profit lock trigger and offset thresholds |
+| `BOLLINGER_*` | Bollinger bandwidth filters for the trend engine |
 | `PRICE_TICK` / `QTY_STEP` | Exchange precision filters for price and quantity |
 | `POLL_INTERVAL_MS` | Trend engine polling cadence in milliseconds |
 | `MAX_CLOSE_SLIPPAGE_PCT` | Allowed deviation vs mark price when closing |
-| `MAKER_*` | Maker strategy knobs: chase threshold, quote offsets, refresh cadence, etc. |
+| `MAKER_*` | Maker-specific knobs (quote offsets, refresh cadence, slippage guard, etc.) |

-To trade on GRVT, set `EXCHANGE=grvt` and populate `GRVT_API_KEY`, `GRVT_API_SECRET`, `GRVT_SUB_ACCOUNT_ID`, plus any optional overrides documented in `.env.example`.
-
-> Tip: you can temporarily override the exchange via CLI flags (takes precedence over environment):
+> CLI flags override environment variables at runtime:
 > ```bash
-> bun run index.ts --exchange grvt
-> bun run index.ts -e lighter
+> bun run index.ts --exchange grvt --strategy maker
+> bun run index.ts -e lighter -s offset-maker --silent
 > ```

-## Common Commands
+## Exchange Setup Guides
+### Aster
+1. Keep `EXCHANGE=aster` (default value).
+2. Supply `ASTER_API_KEY` and `ASTER_API_SECRET`.
+3. Adjust `TRADE_SYMBOL`, `PRICE_TICK`, and `QTY_STEP` to match the requested market.
+4. The bootstrap script auto-populates these variables; manual installs must maintain them.
+
+### GRVT
+1. Set `EXCHANGE=grvt` inside `.env`.
+2. Fill `GRVT_API_KEY`, `GRVT_API_SECRET`, and `GRVT_SUB_ACCOUNT_ID`.
+3. Use `GRVT_ENV=testnet` when targeting the test environment, and align `GRVT_INSTRUMENT` / `GRVT_SYMBOL`.
+4. Optional: provide `GRVT_COOKIE` or a custom `GRVT_SIGNER_PATH` when reusing an existing session.
+
+### Lighter
+1. Set `EXCHANGE=lighter`.
+2. Provide `LIGHTER_ACCOUNT_INDEX` and `LIGHTER_API_PRIVATE_KEY` (40-byte hex private key).
+3. Switch `LIGHTER_ENV` to `mainnet`, `staging`, or `dev` when necessary; override `LIGHTER_BASE_URL` if endpoints differ.
+4. `LIGHTER_SYMBOL` defaults to `BTCUSDT`; override price/size decimals when markets differ.
+
+### Backpack
+1. Set `EXCHANGE=backpack`.
+2. Populate `BACKPACK_API_KEY`, `BACKPACK_API_SECRET`, and `BACKPACK_PASSWORD`; add `BACKPACK_SUBACCOUNT` if you trade from a subaccount.
+3. Toggle `BACKPACK_SANDBOX=true` for the sandbox environment and verify `BACKPACK_SYMBOL` matches the contract (defaults to `BTC_USD_PERP`).
+4. Enable `BACKPACK_DEBUG=true` for verbose adapter logging.
+
+### Paradex
+1. Set `EXCHANGE=paradex`.
+2. Provide `PARADEX_PRIVATE_KEY` (EVM private key) and `PARADEX_WALLET_ADDRESS`.
+3. The adapter connects to mainnet by default; enable `PARADEX_SANDBOX=true` and adjust `PARADEX_SYMBOL` for testnet usage.
+4. Advanced tuning: use `PARADEX_USE_PRO`, `PARADEX_RECONNECT_DELAY_MS`, or debug flags as needed.
+
+## Command Cheatsheet
 ```bash
-bun run index.ts   # Launch the CLI
-bun run start      # Same as above
+bun run index.ts   # Launch the CLI (default entrypoint)
+bun run start      # Alias for bun run index.ts
 bun run dev        # Development entrypoint
-bun x vitest run   # Execute the Vitest suite
+bun x vitest run   # Execute the full Vitest suite
 ```

 ## Silent & Background Execution
 ### Direct silent launch
-Skip the Ink menu and start a strategy straight from the CLI:
-
+Skip the Ink menu and start a strategy directly:
 ```bash
-bun run index.ts --strategy trend --silent        # Trend engine
-bun run index.ts --strategy maker --silent        # Maker engine
-bun run index.ts --strategy offset-maker --silent # Offset maker engine
-```
-
-Combine with `--exchange/-e` to explicitly choose the venue (overrides `EXCHANGE`/`TRADE_EXCHANGE` from `.env`):
-
-```bash
-bun run index.ts --exchange grvt --strategy maker --silent
-bun run index.ts -e lighter -s offset-maker --silent
+bun run index.ts --strategy trend --silent
+bun run index.ts --strategy maker --silent
+bun run index.ts --strategy offset-maker --silent
 ```
+Combine with `--exchange/-e` to pin the venue for that run.

 ### Package scripts
-Convenience aliases are exposed in `package.json`:
-
+Convenience aliases exposed via `package.json`:
 ```bash
 bun run start:trend:silent
 bun run start:maker:silent
@@ -110,42 +150,38 @@ bun run start:offset:silent
 ```

 ### Daemonising with pm2
-Install `pm2` locally (e.g. `bun add -d pm2`) and launch without a global install:
-
+Install `pm2` locally (e.g. `bun add -d pm2`) and launch the process:
 ```bash
 bunx pm2 start bun --name ritmex-trend --cwd . --restart-delay 5000 -- run index.ts --strategy trend --silent
 ```
-
-You can also reuse the bundled scripts:
-
+You can also call the bundled scripts:
 ```bash
 bun run pm2:start:trend
 bun run pm2:start:maker
 bun run pm2:start:offset
 ```
-
-Adjust `--name`, `--cwd`, or `--restart-delay` to suit your environment and run `pm2 save` if you want the process to auto-start after reboot.
+Run `pm2 save` afterwards if you want the process list to survive reboots.

 ## Testing
-Vitest powers the unit tests:
+Powered by Vitest:
 ```bash
 bun run test
 bun x vitest --watch
 ```

 ## Troubleshooting
- You need at least 50–100 USDT of capital before deploying a live strategy.
- Set leverage on the exchange beforehand (around 50x is recommended); the bot does not change it for you.
- Keep server/desktop time in sync with real-world time to avoid signature errors.
- Make sure the exchange account is in one-way position mode.
- **Env not loading**: ensure `.env` resides in the repository root and variable names are spelled correctly.
- **Order rejected for precision**: align `PRICE_TICK`, `QTY_STEP`, and `TRADE_SYMBOL` with the exchange filters.
- **Permission or auth errors**: double-check exchange API scopes.
-More step-by-step guidance is available in [simple-readme.md](simple-readme.md).
+- Keep at least 50–100 USDT in the account before deploying a live strategy.
+- Configure leverage on the exchange manually (~50x is recommended); the bot will not change it.
+- Ensure your server or workstation clock is in sync to avoid signature errors.
+- Accounts must run in one-way position mode.
+- **Env not loading**: make sure `.env` lives in the repo root and variable names are spelled correctly.
+- **Permission rejected**: confirm the API key has perpetual trading scopes enabled.
+- **Precision errors**: align `PRICE_TICK`, `QTY_STEP`, and `TRADE_SYMBOL` with the exchange filters.
+See [simple-readme.md](simple-readme.md) for more detailed walkthroughs.

 ## Community & Support
 - Telegram: [https://t.me/+4fdo0quY87o4Mjhh](https://t.me/+4fdo0quY87o4Mjhh)
- Issues and PRs are welcome for bug reports and feature ideas
+- Issues and PRs are welcome for bug reports and feature requests

 ## Disclaimer
-Algorithmic trading carries risk. Validate strategies with paper accounts or small capital first, safeguard your API keys, and only grant the minimum required permissions.
+Algorithmic trading carries risk. Validate strategies with paper trading or small capital first, safeguard your API keys, and only grant the minimum required permissions.
@@ -5,8 +5,9 @@
      "name": "ritmex-bot",
      "dependencies": {
        "@grvt/client": "^1.6.4",
+        "@noble/ed25519": "^3.0.0",
        "axios": "^1.12.2",
-        "ccxt": "^4.5.5",
+        "ccxt": "^4.5.12",
        "dotenv": "^17.2.2",
        "ethereum-cryptography": "^2.1.3",
        "ink": "^6.3.1",
@@ -83,6 +84,8 @@

    "@noble/curves": ["@noble/curves@1.4.2", "", { "dependencies": { "@noble/hashes": "1.4.0" } }, "sha512-TavHr8qycMChk8UwMld0ZDRvatedkzWfH8IiaeGCfymOP5i0hSCozz9vHOL0nkwk7HRMlFnAiKpS2jrUmSybcw=="],

+    "@noble/ed25519": ["@noble/ed25519@3.0.0", "", {}, "sha512-QyteqMNm0GLqfa5SoYbSC3+Pvykwpn95Zgth4MFVSMKBB75ELl9tX1LAVsN4c3HXOrakHsF2gL4zWDAYCcsnzg=="],
+
    "@noble/hashes": ["@noble/hashes@1.4.0", "", {}, "sha512-V1JJ1WTRUqHHrOSh597hURcMqVKVGL/ea3kv0gSnEdsEZ0/+VyPghM1lMNGc00z7CIQorSvbKpuJkxvuHbvdbg=="],

    "@rollup/rollup-android-arm-eabi": ["@rollup/rollup-android-arm-eabi@4.52.0", "", { "os": "android", "cpu": "arm" }, "sha512-VxDYCDqOaR7NXzAtvRx7G1u54d2kEHopb28YH/pKzY6y0qmogP3gG7CSiWsq9WvDFxOQMpNEyjVAHZFXfH3o/A=="],
@@ -185,7 +188,7 @@

    "call-bind-apply-helpers": ["call-bind-apply-helpers@1.0.2", "", { "dependencies": { "es-errors": "^1.3.0", "function-bind": "^1.1.2" } }, "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ=="],

-    "ccxt": ["ccxt@4.5.5", "", { "dependencies": { "ws": "^8.8.1" } }, "sha512-AyhwTFLkx4sO985ImIOfumEBox7AHD/iqk5tPGICObUSZG6wTXg0aRzU8Hjz974aCMG4msFwLk3A/iXPKAU4wA=="],
+    "ccxt": ["ccxt@4.5.12", "", { "dependencies": { "ws": "^8.8.1" } }, "sha512-2lfL2TKjq4vBkQUQWJfDqFywhvYCZmk9r0SWC8GqA4AHZ6qozKVUJowxQTvdRsLX9jBwYSE0nc7JVurBrQ6SHg=="],

    "chai": ["chai@5.3.3", "", { "dependencies": { "assertion-error": "^2.0.1", "check-error": "^2.1.1", "deep-eql": "^5.0.1", "loupe": "^3.1.0", "pathval": "^2.0.0" } }, "sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw=="],

@@ -1,4 +0,0 @@
-.idea
-vendor
-build/*
-!build/.keep
@@ -1,9 +0,0 @@
-# lighter-go
-
-In its current form, this repo serves as a starting point for anyone who wants to trade on Lighter using GO.
-It covers all the signing procedures in order to trade on Lighter with an API key.
-Minimal HTTP calls are implemented 
-On chain support, like depositing on Ethereum or modifying an API key directly with an Ethereum Tx are not supported yet. 
-
-At the moment, its main purpose is to offer visibility on the code behind the precompiled libraries used by the Python SDK.
-If you'd like to compile your own binaries, the commands are in the `justfile`
@@ -1,659 +0,0 @@
-package types
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/elliottech/lighter-go/signer"
-	"github.com/elliottech/lighter-go/types/txtypes"
-	g "github.com/elliottech/poseidon_crypto/field/goldilocks"
-	gFp5 "github.com/elliottech/poseidon_crypto/field/goldilocks_quintic_extension"
-	p2 "github.com/elliottech/poseidon_crypto/hash/poseidon2_goldilocks"
-	ethCommon "github.com/ethereum/go-ethereum/common"
-)
-
-type TransactOpts struct {
-	FromAccountIndex *int64
-	ApiKeyIndex      *uint8
-	ExpiredAt        int64
-	Nonce            *int64
-	DryRun           bool
-}
-
-type PublicKey = gFp5.Element
-
-type ChangePubKeyReq struct {
-	PubKey [40]byte
-}
-
-type TransferTxReq struct {
-	ToAccountIndex int64
-	USDCAmount     int64
-	Fee            int64
-	Memo           [32]byte
-}
-
-type WithdrawTxReq struct {
-	USDCAmount uint64
-}
-
-type CreateOrderTxReq struct {
-	MarketIndex      uint8
-	ClientOrderIndex int64
-	BaseAmount       int64
-	Price            uint32
-	IsAsk            uint8
-	Type             uint8
-	TimeInForce      uint8
-	ReduceOnly       uint8
-	TriggerPrice     uint32
-	OrderExpiry      int64
-}
-
-type CreateGroupedOrdersTxReq struct {
-	GroupingType uint8
-	Orders       []*CreateOrderTxReq
-}
-
-type ModifyOrderTxReq struct {
-	MarketIndex  uint8
-	Index        int64
-	BaseAmount   int64
-	Price        uint32
-	TriggerPrice uint32
-}
-
-type CancelOrderTxReq struct {
-	MarketIndex uint8
-	Index       int64
-}
-
-type CancelAllOrdersTxReq struct {
-	TimeInForce uint8
-	Time        int64
-}
-
-type CreatePublicPoolTxReq struct {
-	OperatorFee          int64
-	InitialTotalShares   int64
-	MinOperatorShareRate int64
-}
-
-type UpdatePublicPoolTxReq struct {
-	PublicPoolIndex      int64
-	Status               uint8
-	OperatorFee          int64
-	MinOperatorShareRate int64
-}
-
-type MintSharesTxReq struct {
-	PublicPoolIndex int64
-	ShareAmount     int64
-}
-
-type BurnSharesTxReq struct {
-	PublicPoolIndex int64
-	ShareAmount     int64
-}
-
-type UpdateLeverageTxReq struct {
-	MarketIndex           uint8
-	InitialMarginFraction uint16
-	MarginMode            uint8
-}
-
-type UpdateMarginTxReq struct {
-	MarketIndex uint8
-	USDCAmount  int64
-	Direction   uint8
-}
-
-func ConstructAuthToken(key signer.Signer, deadline time.Time, ops *TransactOpts) (string, error) {
-	if ops.FromAccountIndex == nil {
-		return "", fmt.Errorf("missing FromAccountIndex")
-	}
-	if ops.ApiKeyIndex == nil {
-		return "", fmt.Errorf("missing ApiKeyIndex")
-	}
-	message := fmt.Sprintf("%v:%v:%v", deadline.Unix(), *ops.FromAccountIndex, *ops.ApiKeyIndex)
-
-	msgInField, err := g.ArrayFromCanonicalLittleEndianBytes([]byte(message))
-	if err != nil {
-		return "", fmt.Errorf("failed to convert bytes to field element. message: %s, error: %w", message, err)
-	}
-
-	msgHash := p2.HashToQuinticExtension(msgInField).ToLittleEndianBytes()
-
-	signatureBytes, err := key.Sign(msgHash, p2.NewPoseidon2())
-	if err != nil {
-		return "", err
-	}
-	signature := ethCommon.Bytes2Hex(signatureBytes)
-
-	return fmt.Sprintf("%v:%v", message, signature), err
-}
-
-func ConstructChangePubKeyTx(key signer.Signer, lighterChainId uint32, tx *ChangePubKeyReq, ops *TransactOpts) (*txtypes.L2ChangePubKeyTxInfo, error) {
-	convertedTx := ConvertChangePubKeyTx(tx, ops)
-	err := convertedTx.Validate()
-	if err != nil {
-		return nil, err
-	}
-
-	msgHash, err := convertedTx.Hash(lighterChainId)
-	if err != nil {
-		return nil, err
-	}
-
-	signature, err := key.Sign(msgHash, p2.NewPoseidon2())
-	if err != nil {
-		return nil, err
-	}
-
-	convertedTx.SignedHash = ethCommon.Bytes2Hex(msgHash)
-	convertedTx.Sig = signature
-	return convertedTx, nil
-}
-
-func ConstructCreateSubAccountTx(key signer.Signer, lighterChainId uint32, ops *TransactOpts) (*txtypes.L2CreateSubAccountTxInfo, error) {
-	convertedTx := ConvertCreateSubAccountTx(ops)
-	err := convertedTx.Validate()
-	if err != nil {
-		return nil, err
-	}
-
-	msgHash, err := convertedTx.Hash(lighterChainId)
-	if err != nil {
-		return nil, err
-	}
-
-	signature, err := key.Sign(msgHash, p2.NewPoseidon2())
-	if err != nil {
-		return nil, err
-	}
-
-	convertedTx.SignedHash = ethCommon.Bytes2Hex(msgHash)
-	convertedTx.Sig = signature
-	return convertedTx, nil
-}
-
-func ConstructCreatePublicPoolTx(key signer.Signer, lighterChainId uint32, tx *CreatePublicPoolTxReq, ops *TransactOpts) (*txtypes.L2CreatePublicPoolTxInfo, error) {
-	convertedTx := ConvertCreatePublicPoolTx(tx, ops)
-	err := convertedTx.Validate()
-	if err != nil {
-		return nil, err
-	}
-
-	msgHash, err := convertedTx.Hash(lighterChainId)
-	if err != nil {
-		return nil, err
-	}
-
-	signature, err := key.Sign(msgHash, p2.NewPoseidon2())
-	if err != nil {
-		return nil, err
-	}
-
-	convertedTx.SignedHash = ethCommon.Bytes2Hex(msgHash)
-	convertedTx.Sig = signature
-	return convertedTx, nil
-}
-
-func ConstructUpdatePublicPoolTx(key signer.Signer, lighterChainId uint32, tx *UpdatePublicPoolTxReq, ops *TransactOpts) (*txtypes.L2UpdatePublicPoolTxInfo, error) {
-	convertedTx := ConvertUpdatePublicPoolTx(tx, ops)
-	err := convertedTx.Validate()
-	if err != nil {
-		return nil, err
-	}
-
-	msgHash, err := convertedTx.Hash(lighterChainId)
-	if err != nil {
-		return nil, err
-	}
-
-	signature, err := key.Sign(msgHash, p2.NewPoseidon2())
-	if err != nil {
-		return nil, err
-	}
-
-	convertedTx.SignedHash = ethCommon.Bytes2Hex(msgHash)
-	convertedTx.Sig = signature
-	return convertedTx, nil
-}
-
-func ConstructWithdrawTx(key signer.Signer, lighterChainId uint32, tx *WithdrawTxReq, ops *TransactOpts) (*txtypes.L2WithdrawTxInfo, error) {
-	convertedTx := ConvertWithdrawTx(tx, ops)
-	err := convertedTx.Validate()
-	if err != nil {
-		return nil, err
-	}
-
-	msgHash, err := convertedTx.Hash(lighterChainId)
-	if err != nil {
-		return nil, err
-	}
-
-	signature, err := key.Sign(msgHash, p2.NewPoseidon2())
-	if err != nil {
-		return nil, err
-	}
-
-	convertedTx.SignedHash = ethCommon.Bytes2Hex(msgHash)
-	convertedTx.Sig = signature
-	return convertedTx, nil
-}
-
-func ConstructCreateOrderTx(key signer.Signer, lighterChainId uint32, tx *CreateOrderTxReq, ops *TransactOpts) (*txtypes.L2CreateOrderTxInfo, error) {
-	convertedTx := ConvertCreateOrderTx(tx, ops)
-	err := convertedTx.Validate()
-	if err != nil {
-		return nil, err
-	}
-
-	msgHash, err := convertedTx.Hash(lighterChainId)
-	if err != nil {
-		return nil, err
-	}
-
-	signature, err := key.Sign(msgHash, p2.NewPoseidon2())
-	if err != nil {
-		return nil, err
-	}
-
-	convertedTx.SignedHash = ethCommon.Bytes2Hex(msgHash)
-	convertedTx.Sig = signature
-	return convertedTx, nil
-}
-
-func ConstructL2CreateGroupedOrdersTx(key signer.Signer, lighterChainId uint32, tx *CreateGroupedOrdersTxReq, ops *TransactOpts) (*txtypes.L2CreateGroupedOrdersTxInfo, error) {
-	convertedTx := ConvertCreateGroupedOrdersTx(tx, ops)
-	err := convertedTx.Validate()
-	if err != nil {
-		return nil, err
-	}
-
-	msgHash, err := convertedTx.Hash(lighterChainId)
-	if err != nil {
-		return nil, err
-	}
-
-	signature, err := key.Sign(msgHash, p2.NewPoseidon2())
-	if err != nil {
-		return nil, err
-	}
-
-	convertedTx.SignedHash = ethCommon.Bytes2Hex(msgHash)
-	convertedTx.Sig = signature
-	return convertedTx, nil
-}
-
-func ConstructL2CancelOrderTx(key signer.Signer, lighterChainId uint32, tx *CancelOrderTxReq, ops *TransactOpts) (*txtypes.L2CancelOrderTxInfo, error) {
-	convertedTx := ConvertCancelOrderTx(tx, ops)
-	err := convertedTx.Validate()
-	if err != nil {
-		return nil, err
-	}
-
-	msgHash, err := convertedTx.Hash(lighterChainId)
-	if err != nil {
-		return nil, err
-	}
-
-	signature, err := key.Sign(msgHash, p2.NewPoseidon2())
-	if err != nil {
-		return nil, err
-	}
-
-	convertedTx.SignedHash = ethCommon.Bytes2Hex(msgHash)
-	convertedTx.Sig = signature
-	return convertedTx, nil
-}
-
-func ConstructL2ModifyOrderTx(key signer.Signer, lighterChainId uint32, tx *ModifyOrderTxReq, ops *TransactOpts) (*txtypes.L2ModifyOrderTxInfo, error) {
-	convertedTx := ConvertModifyOrderTx(tx, ops)
-	err := convertedTx.Validate()
-	if err != nil {
-		return nil, err
-	}
-
-	msgHash, err := convertedTx.Hash(lighterChainId)
-	if err != nil {
-		return nil, err
-	}
-
-	signature, err := key.Sign(msgHash, p2.NewPoseidon2())
-	if err != nil {
-		return nil, err
-	}
-
-	convertedTx.SignedHash = ethCommon.Bytes2Hex(msgHash)
-	convertedTx.Sig = signature
-	return convertedTx, nil
-}
-
-func ConstructL2CancelAllOrdersTx(key signer.Signer, lighterChainId uint32, tx *CancelAllOrdersTxReq, ops *TransactOpts) (*txtypes.L2CancelAllOrdersTxInfo, error) {
-	convertedTx := ConvertCancelAllOrdersTx(tx, ops)
-	err := convertedTx.Validate()
-	if err != nil {
-		return nil, err
-	}
-
-	msgHash, err := convertedTx.Hash(lighterChainId)
-	if err != nil {
-		return nil, err
-	}
-
-	signature, err := key.Sign(msgHash, p2.NewPoseidon2())
-	if err != nil {
-		return nil, err
-	}
-
-	convertedTx.SignedHash = ethCommon.Bytes2Hex(msgHash)
-	convertedTx.Sig = signature
-	return convertedTx, nil
-}
-
-func ConstructTransferTx(key signer.Signer, lighterChainId uint32, tx *TransferTxReq, ops *TransactOpts) (*txtypes.L2TransferTxInfo, error) {
-	convertedTx := ConvertTransferTx(tx, ops)
-	err := convertedTx.Validate()
-	if err != nil {
-		return nil, err
-	}
-
-	msgHash, err := convertedTx.Hash(lighterChainId)
-	if err != nil {
-		return nil, err
-	}
-
-	signature, err := key.Sign(msgHash, p2.NewPoseidon2())
-	if err != nil {
-		return nil, err
-	}
-
-	convertedTx.SignedHash = ethCommon.Bytes2Hex(msgHash)
-	convertedTx.Sig = signature
-	return convertedTx, nil
-}
-
-func ConstructMintSharesTx(key signer.Signer, lighterChainId uint32, tx *MintSharesTxReq, ops *TransactOpts) (*txtypes.L2MintSharesTxInfo, error) {
-	convertedTx := ConvertMintSharesTx(tx, ops)
-	err := convertedTx.Validate()
-	if err != nil {
-		return nil, err
-	}
-
-	msgHash, err := convertedTx.Hash(lighterChainId)
-	if err != nil {
-		return nil, err
-	}
-
-	signature, err := key.Sign(msgHash, p2.NewPoseidon2())
-	if err != nil {
-		return nil, err
-	}
-
-	convertedTx.SignedHash = ethCommon.Bytes2Hex(msgHash)
-	convertedTx.Sig = signature
-	return convertedTx, nil
-}
-
-func ConstructBurnSharesTx(key signer.Signer, lighterChainId uint32, tx *BurnSharesTxReq, ops *TransactOpts) (*txtypes.L2BurnSharesTxInfo, error) {
-	convertedTx := ConvertBurnSharesTx(tx, ops)
-	err := convertedTx.Validate()
-	if err != nil {
-		return nil, err
-	}
-
-	msgHash, err := convertedTx.Hash(lighterChainId)
-	if err != nil {
-		return nil, err
-	}
-
-	signature, err := key.Sign(msgHash, p2.NewPoseidon2())
-	if err != nil {
-		return nil, err
-	}
-
-	convertedTx.SignedHash = ethCommon.Bytes2Hex(msgHash)
-	convertedTx.Sig = signature
-	return convertedTx, nil
-}
-
-func ConstructUpdateLeverageTx(key signer.Signer, lighterChainId uint32, tx *UpdateLeverageTxReq, ops *TransactOpts) (*txtypes.L2UpdateLeverageTxInfo, error) {
-	convertedTx := ConvertUpdateLeverageTx(tx, ops)
-	err := convertedTx.Validate()
-	if err != nil {
-		return nil, err
-	}
-
-	msgHash, err := convertedTx.Hash(lighterChainId)
-	if err != nil {
-		return nil, err
-	}
-
-	signature, err := key.Sign(msgHash, p2.NewPoseidon2())
-	if err != nil {
-		return nil, err
-	}
-
-	convertedTx.SignedHash = ethCommon.Bytes2Hex(msgHash)
-	convertedTx.Sig = signature
-	return convertedTx, nil
-}
-
-func ConstructUpdateMarginTx(key signer.Signer, lighterChainId uint32, tx *UpdateMarginTxReq, ops *TransactOpts) (*txtypes.L2UpdateMarginTxInfo, error) {
-	convertedTx := ConvertUpdateMarginTx(tx, ops)
-	err := convertedTx.Validate()
-	if err != nil {
-		return nil, err
-	}
-
-	msgHash, err := convertedTx.Hash(lighterChainId)
-	if err != nil {
-		return nil, err
-	}
-
-	signature, err := key.Sign(msgHash, p2.NewPoseidon2())
-	if err != nil {
-		return nil, err
-	}
-
-	convertedTx.SignedHash = ethCommon.Bytes2Hex(msgHash)
-	convertedTx.Sig = signature
-	return convertedTx, nil
-}
-
-func ConvertTransferTx(tx *TransferTxReq, ops *TransactOpts) *txtypes.L2TransferTxInfo {
-	return &txtypes.L2TransferTxInfo{
-		FromAccountIndex: *ops.FromAccountIndex,
-		ApiKeyIndex:      *ops.ApiKeyIndex,
-		ToAccountIndex:   tx.ToAccountIndex,
-		USDCAmount:       tx.USDCAmount,
-		Fee:              tx.Fee,
-		Memo:             tx.Memo,
-		ExpiredAt:        ops.ExpiredAt,
-		Nonce:            *ops.Nonce,
-	}
-}
-
-func ConvertCreateOrderTx(tx *CreateOrderTxReq, ops *TransactOpts) *txtypes.L2CreateOrderTxInfo {
-	return &txtypes.L2CreateOrderTxInfo{
-		AccountIndex: *ops.FromAccountIndex,
-		ApiKeyIndex:  *ops.ApiKeyIndex,
-		OrderInfo: &txtypes.OrderInfo{MarketIndex: tx.MarketIndex,
-			ClientOrderIndex: tx.ClientOrderIndex,
-			BaseAmount:       tx.BaseAmount,
-			Price:            tx.Price,
-			IsAsk:            tx.IsAsk,
-			Type:             tx.Type,
-			TimeInForce:      tx.TimeInForce,
-			ReduceOnly:       tx.ReduceOnly,
-			TriggerPrice:     tx.TriggerPrice,
-			OrderExpiry:      tx.OrderExpiry,
-		},
-		ExpiredAt: ops.ExpiredAt,
-		Nonce:     *ops.Nonce,
-	}
-}
-
-func ConvertCreateGroupedOrdersTx(tx *CreateGroupedOrdersTxReq, ops *TransactOpts) *txtypes.L2CreateGroupedOrdersTxInfo {
-	ret := &txtypes.L2CreateGroupedOrdersTxInfo{
-		AccountIndex: *ops.FromAccountIndex,
-		ApiKeyIndex:  *ops.ApiKeyIndex,
-		GroupingType: tx.GroupingType,
-		Orders:       []*txtypes.OrderInfo{},
-		ExpiredAt:    ops.ExpiredAt,
-		Nonce:        *ops.Nonce,
-	}
-
-	for _, order := range tx.Orders {
-		ret.Orders = append(ret.Orders, &txtypes.OrderInfo{
-			MarketIndex:      order.MarketIndex,
-			ClientOrderIndex: order.ClientOrderIndex,
-			BaseAmount:       order.BaseAmount,
-			Price:            order.Price,
-			IsAsk:            order.IsAsk,
-			Type:             order.Type,
-			TimeInForce:      order.TimeInForce,
-			ReduceOnly:       order.ReduceOnly,
-			TriggerPrice:     order.TriggerPrice,
-			OrderExpiry:      order.OrderExpiry,
-		})
-	}
-	return ret
-}
-
-func ConvertCancelOrderTx(tx *CancelOrderTxReq, ops *TransactOpts) *txtypes.L2CancelOrderTxInfo {
-	return &txtypes.L2CancelOrderTxInfo{
-		AccountIndex: *ops.FromAccountIndex,
-		ApiKeyIndex:  *ops.ApiKeyIndex,
-		MarketIndex:  tx.MarketIndex,
-		Index:        tx.Index,
-		ExpiredAt:    ops.ExpiredAt,
-		Nonce:        *ops.Nonce,
-	}
-}
-
-func ConvertModifyOrderTx(tx *ModifyOrderTxReq, ops *TransactOpts) *txtypes.L2ModifyOrderTxInfo {
-	return &txtypes.L2ModifyOrderTxInfo{
-		AccountIndex: *ops.FromAccountIndex,
-		ApiKeyIndex:  *ops.ApiKeyIndex,
-		MarketIndex:  tx.MarketIndex,
-		Index:        tx.Index,
-		BaseAmount:   tx.BaseAmount,
-		Price:        tx.Price,
-		TriggerPrice: tx.TriggerPrice,
-		ExpiredAt:    ops.ExpiredAt,
-		Nonce:        *ops.Nonce,
-	}
-}
-
-func ConvertCancelAllOrdersTx(tx *CancelAllOrdersTxReq, ops *TransactOpts) *txtypes.L2CancelAllOrdersTxInfo {
-	return &txtypes.L2CancelAllOrdersTxInfo{
-		AccountIndex: *ops.FromAccountIndex,
-		ApiKeyIndex:  *ops.ApiKeyIndex,
-		TimeInForce:  tx.TimeInForce,
-		Time:         tx.Time,
-		ExpiredAt:    ops.ExpiredAt,
-		Nonce:        *ops.Nonce,
-	}
-}
-
-func ConvertWithdrawTx(tx *WithdrawTxReq, ops *TransactOpts) *txtypes.L2WithdrawTxInfo {
-	return &txtypes.L2WithdrawTxInfo{
-		FromAccountIndex: *ops.FromAccountIndex,
-		ApiKeyIndex:      *ops.ApiKeyIndex,
-		USDCAmount:       tx.USDCAmount,
-		ExpiredAt:        ops.ExpiredAt,
-		Nonce:            *ops.Nonce,
-	}
-}
-
-func ConvertChangePubKeyTx(tx *ChangePubKeyReq, ops *TransactOpts) *txtypes.L2ChangePubKeyTxInfo {
-	return &txtypes.L2ChangePubKeyTxInfo{
-		AccountIndex: *ops.FromAccountIndex,
-		ApiKeyIndex:  *ops.ApiKeyIndex,
-		PubKey:       tx.PubKey[:],
-		ExpiredAt:    ops.ExpiredAt,
-		Nonce:        *ops.Nonce,
-	}
-}
-
-func ConvertCreateSubAccountTx(ops *TransactOpts) *txtypes.L2CreateSubAccountTxInfo {
-	return &txtypes.L2CreateSubAccountTxInfo{
-		AccountIndex: *ops.FromAccountIndex,
-		ApiKeyIndex:  *ops.ApiKeyIndex,
-		ExpiredAt:    ops.ExpiredAt,
-		Nonce:        *ops.Nonce,
-	}
-}
-
-func ConvertCreatePublicPoolTx(tx *CreatePublicPoolTxReq, ops *TransactOpts) *txtypes.L2CreatePublicPoolTxInfo {
-	return &txtypes.L2CreatePublicPoolTxInfo{
-		AccountIndex:         *ops.FromAccountIndex,
-		ApiKeyIndex:          *ops.ApiKeyIndex,
-		OperatorFee:          tx.OperatorFee,
-		InitialTotalShares:   tx.InitialTotalShares,
-		MinOperatorShareRate: tx.MinOperatorShareRate,
-		ExpiredAt:            ops.ExpiredAt,
-		Nonce:                *ops.Nonce,
-	}
-}
-
-func ConvertUpdatePublicPoolTx(tx *UpdatePublicPoolTxReq, ops *TransactOpts) *txtypes.L2UpdatePublicPoolTxInfo {
-	return &txtypes.L2UpdatePublicPoolTxInfo{
-		AccountIndex:         *ops.FromAccountIndex,
-		ApiKeyIndex:          *ops.ApiKeyIndex,
-		PublicPoolIndex:      tx.PublicPoolIndex,
-		Status:               tx.Status,
-		OperatorFee:          tx.OperatorFee,
-		MinOperatorShareRate: tx.MinOperatorShareRate,
-		ExpiredAt:            ops.ExpiredAt,
-		Nonce:                *ops.Nonce,
-	}
-}
-
-func ConvertMintSharesTx(tx *MintSharesTxReq, ops *TransactOpts) *txtypes.L2MintSharesTxInfo {
-	return &txtypes.L2MintSharesTxInfo{
-		AccountIndex:    *ops.FromAccountIndex,
-		ApiKeyIndex:     *ops.ApiKeyIndex,
-		PublicPoolIndex: tx.PublicPoolIndex,
-		ShareAmount:     tx.ShareAmount,
-		ExpiredAt:       ops.ExpiredAt,
-		Nonce:           *ops.Nonce,
-	}
-}
-
-func ConvertBurnSharesTx(tx *BurnSharesTxReq, ops *TransactOpts) *txtypes.L2BurnSharesTxInfo {
-	return &txtypes.L2BurnSharesTxInfo{
-		AccountIndex:    *ops.FromAccountIndex,
-		ApiKeyIndex:     *ops.ApiKeyIndex,
-		PublicPoolIndex: tx.PublicPoolIndex,
-		ShareAmount:     tx.ShareAmount,
-		ExpiredAt:       ops.ExpiredAt,
-		Nonce:           *ops.Nonce,
-	}
-}
-
-func ConvertUpdateLeverageTx(tx *UpdateLeverageTxReq, ops *TransactOpts) *txtypes.L2UpdateLeverageTxInfo {
-	return &txtypes.L2UpdateLeverageTxInfo{
-		AccountIndex:          *ops.FromAccountIndex,
-		ApiKeyIndex:           *ops.ApiKeyIndex,
-		MarketIndex:           tx.MarketIndex,
-		InitialMarginFraction: tx.InitialMarginFraction,
-		ExpiredAt:             ops.ExpiredAt,
-		Nonce:                 *ops.Nonce,
-	}
-}
-
-func ConvertUpdateMarginTx(tx *UpdateMarginTxReq, ops *TransactOpts) *txtypes.L2UpdateMarginTxInfo {
-	return &txtypes.L2UpdateMarginTxInfo{
-		AccountIndex: *ops.FromAccountIndex,
-		ApiKeyIndex:  *ops.ApiKeyIndex,
-		MarketIndex:  tx.MarketIndex,
-		USDCAmount:   tx.USDCAmount,
-		Direction:    tx.Direction,
-		ExpiredAt:    ops.ExpiredAt,
-		Nonce:        *ops.Nonce,
-	}
-}
@@ -1,91 +0,0 @@
-package txtypes
-
-import (
-	g "github.com/elliottech/poseidon_crypto/field/goldilocks"
-	p2 "github.com/elliottech/poseidon_crypto/hash/poseidon2_goldilocks"
-)
-
-var _ TxInfo = (*L2BurnSharesTxInfo)(nil)
-
-type L2BurnSharesTxInfo struct {
-	AccountIndex int64
-	ApiKeyIndex  uint8
-
-	PublicPoolIndex int64
-	ShareAmount     int64
-
-	ExpiredAt  int64
-	Nonce      int64
-	Sig        []byte
-	SignedHash string `json:"-"`
-}
-
-func (txInfo *L2BurnSharesTxInfo) GetTxType() uint8 {
-	return TxTypeL2BurnShares
-}
-
-func (txInfo *L2BurnSharesTxInfo) GetTxInfo() (string, error) {
-	return getTxInfo(txInfo)
-}
-
-func (txInfo *L2BurnSharesTxInfo) GetTxHash() string {
-	return txInfo.SignedHash
-}
-
-func (txInfo *L2BurnSharesTxInfo) Validate() error {
-	if txInfo.AccountIndex < MinAccountIndex {
-		return ErrFromAccountIndexTooLow
-	}
-	if txInfo.AccountIndex > MaxAccountIndex {
-		return ErrFromAccountIndexTooHigh
-	}
-
-	// ApiKeyIndex
-	if txInfo.ApiKeyIndex < MinApiKeyIndex {
-		return ErrApiKeyIndexTooLow
-	}
-	if txInfo.ApiKeyIndex > MaxApiKeyIndex {
-		return ErrApiKeyIndexTooHigh
-	}
-
-	// PublicPoolIndex
-	if txInfo.PublicPoolIndex < MinAccountIndex {
-		return ErrPublicPoolIndexTooLow
-	}
-	if txInfo.PublicPoolIndex > MaxAccountIndex {
-		return ErrPublicPoolIndexTooHigh
-	}
-
-	if txInfo.ShareAmount < MinPoolSharesToMintOrBurn {
-		return ErrPoolBurnShareAmountTooLow
-	}
-	if txInfo.ShareAmount > MaxPoolSharesToMintOrBurn {
-		return ErrPoolBurnShareAmountTooHigh
-	}
-
-	if txInfo.Nonce < MinNonce {
-		return ErrNonceTooLow
-	}
-
-	if txInfo.ExpiredAt < 0 || txInfo.ExpiredAt > MaxTimestamp {
-		return ErrExpiredAtInvalid
-	}
-
-	return nil
-}
-
-func (txInfo *L2BurnSharesTxInfo) Hash(lighterChainId uint32, extra ...g.Element) (msgHash []byte, err error) {
-	elems := make([]g.Element, 0, 8)
-
-	elems = append(elems, g.FromUint32(lighterChainId))
-	elems = append(elems, g.FromUint32(TxTypeL2BurnShares))
-	elems = append(elems, g.FromInt64(txInfo.Nonce))
-	elems = append(elems, g.FromInt64(txInfo.ExpiredAt))
-
-	elems = append(elems, g.FromInt64(txInfo.AccountIndex))
-	elems = append(elems, g.FromUint32(uint32(txInfo.ApiKeyIndex)))
-	elems = append(elems, g.FromInt64(txInfo.PublicPoolIndex))
-	elems = append(elems, g.FromInt64(txInfo.ShareAmount))
-
-	return p2.HashToQuinticExtension(elems).ToLittleEndianBytes(), nil
-}
@@ -1,95 +0,0 @@
-package txtypes
-
-import (
-	g "github.com/elliottech/poseidon_crypto/field/goldilocks"
-	p2 "github.com/elliottech/poseidon_crypto/hash/poseidon2_goldilocks"
-)
-
-var _ TxInfo = (*L2CancelAllOrdersTxInfo)(nil)
-
-type L2CancelAllOrdersTxInfo struct {
-	AccountIndex int64
-	ApiKeyIndex  uint8
-
-	TimeInForce uint8
-	Time        int64
-
-	ExpiredAt  int64
-	Nonce      int64
-	Sig        []byte
-	SignedHash string `json:"-"`
-}
-
-func (txInfo *L2CancelAllOrdersTxInfo) GetTxType() uint8 {
-	return TxTypeL2CancelAllOrders
-}
-
-func (txInfo *L2CancelAllOrdersTxInfo) GetTxInfo() (string, error) {
-	return getTxInfo(txInfo)
-}
-
-func (txInfo *L2CancelAllOrdersTxInfo) GetTxHash() string {
-	return txInfo.SignedHash
-}
-
-func (txInfo *L2CancelAllOrdersTxInfo) Validate() error {
-	// AccountIndex
-	if txInfo.AccountIndex < MinAccountIndex {
-		return ErrAccountIndexTooLow
-	}
-	if txInfo.AccountIndex > MaxAccountIndex {
-		return ErrAccountIndexTooHigh
-	}
-
-	if txInfo.ApiKeyIndex < MinApiKeyIndex {
-		return ErrApiKeyIndexTooLow
-	}
-	if txInfo.ApiKeyIndex > MaxApiKeyIndex && txInfo.ApiKeyIndex != NilApiKeyIndex {
-		return ErrApiKeyIndexTooHigh
-	}
-
-	// Nonce
-	if txInfo.Nonce < MinNonce {
-		return ErrNonceTooLow
-	}
-
-	if txInfo.ExpiredAt < 0 || txInfo.ExpiredAt > MaxTimestamp {
-		return ErrExpiredAtInvalid
-	}
-
-	// TimeInForce and Time
-	switch txInfo.TimeInForce {
-	case ImmediateCancelAll:
-		if txInfo.Time != NilOrderExpiry {
-			return ErrCancelAllTimeisNotNill
-		}
-	case ScheduledCancelAll:
-		if txInfo.Time < MinOrderExpiry || txInfo.Time > MaxOrderExpiry {
-			return ErrCancelAllTimeIsNotInRange
-		}
-	case AbortScheduledCancelAll:
-		if txInfo.Time != 0 {
-			return ErrCancelAllTimeIsNotInRange
-		}
-	default:
-		return ErrInvalidCancelAllTimeInForce
-	}
-
-	return nil
-}
-
-func (txInfo *L2CancelAllOrdersTxInfo) Hash(lighterChainId uint32, extra ...g.Element) (msgHash []byte, err error) {
-	elems := make([]g.Element, 0, 8)
-
-	elems = append(elems, g.FromUint32(lighterChainId))
-	elems = append(elems, g.FromUint32(TxTypeL2CancelAllOrders))
-	elems = append(elems, g.FromInt64(txInfo.Nonce))
-	elems = append(elems, g.FromInt64(txInfo.ExpiredAt))
-
-	elems = append(elems, g.FromInt64(txInfo.AccountIndex))
-	elems = append(elems, g.FromUint32(uint32(txInfo.ApiKeyIndex)))
-	elems = append(elems, g.FromUint32(uint32(txInfo.TimeInForce)))
-	elems = append(elems, g.FromInt64(txInfo.Time))
-
-	return p2.HashToQuinticExtension(elems).ToLittleEndianBytes(), nil
-}
@@ -1,94 +0,0 @@
-package txtypes
-
-import (
-	g "github.com/elliottech/poseidon_crypto/field/goldilocks"
-	p2 "github.com/elliottech/poseidon_crypto/hash/poseidon2_goldilocks"
-)
-
-var _ TxInfo = (*L2CancelOrderTxInfo)(nil)
-
-type L2CancelOrderTxInfo struct {
-	AccountIndex int64
-	ApiKeyIndex  uint8
-
-	MarketIndex uint8
-	Index       int64 // Client Order Index or Order Index of the order to cancel
-
-	ExpiredAt  int64
-	Nonce      int64
-	Sig        []byte
-	SignedHash string `json:"-"`
-}
-
-func (txInfo *L2CancelOrderTxInfo) GetTxType() uint8 {
-	return TxTypeL2CancelOrder
-}
-
-func (txInfo *L2CancelOrderTxInfo) GetTxInfo() (string, error) {
-	return getTxInfo(txInfo)
-}
-
-func (txInfo *L2CancelOrderTxInfo) GetTxHash() string {
-	return txInfo.SignedHash
-}
-
-func (txInfo *L2CancelOrderTxInfo) Validate() error {
-	// AccountIndex
-	if txInfo.AccountIndex < MinAccountIndex {
-		return ErrAccountIndexTooLow
-	}
-	if txInfo.AccountIndex > MaxAccountIndex {
-		return ErrAccountIndexTooHigh
-	}
-
-	// ApiKeyIndex
-	if txInfo.ApiKeyIndex < MinApiKeyIndex {
-		return ErrApiKeyIndexTooLow
-	}
-	if txInfo.ApiKeyIndex > MaxApiKeyIndex {
-		return ErrApiKeyIndexTooHigh
-	}
-
-	// MarketIndex
-	if txInfo.MarketIndex < MinMarketIndex {
-		return ErrMarketIndexTooLow
-	}
-	if txInfo.MarketIndex > MaxMarketIndex {
-		return ErrMarketIndexTooHigh
-	}
-
-	// Index
-	if txInfo.Index < MinClientOrderIndex && txInfo.Index < MinOrderIndex {
-		return ErrOrderIndexTooLow
-	}
-	if txInfo.Index > MaxClientOrderIndex && txInfo.Index > MaxOrderIndex {
-		return ErrOrderIndexTooHigh
-	}
-
-	// Nonce
-	if txInfo.Nonce < MinNonce {
-		return ErrNonceTooLow
-	}
-
-	if txInfo.ExpiredAt < 0 || txInfo.ExpiredAt > MaxTimestamp {
-		return ErrExpiredAtInvalid
-	}
-
-	return nil
-}
-
-func (txInfo *L2CancelOrderTxInfo) Hash(lighterChainId uint32, extra ...g.Element) (msgHash []byte, err error) {
-	elems := make([]g.Element, 0, 7)
-
-	elems = append(elems, g.FromUint32(lighterChainId))
-	elems = append(elems, g.FromUint32(TxTypeL2CancelOrder))
-	elems = append(elems, g.FromInt64(txInfo.Nonce))
-	elems = append(elems, g.FromInt64(txInfo.ExpiredAt))
-
-	elems = append(elems, g.FromInt64(txInfo.AccountIndex))
-	elems = append(elems, g.FromUint32(uint32(txInfo.ApiKeyIndex)))
-	elems = append(elems, g.FromUint32(uint32(txInfo.MarketIndex)))
-	elems = append(elems, g.FromInt64(txInfo.Index))
-
-	return p2.HashToQuinticExtension(elems).ToLittleEndianBytes(), nil
-}
@@ -1,121 +0,0 @@
-package txtypes
-
-import (
-	"fmt"
-	"strings"
-
-	g "github.com/elliottech/poseidon_crypto/field/goldilocks"
-	p2 "github.com/elliottech/poseidon_crypto/hash/poseidon2_goldilocks"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/hexutil"
-)
-
-const (
-	templateChangePubKey = "Register Lighter Account\n\npubkey: 0x%s\nnonce: %s\naccount index: %s\napi key index: %s\nOnly sign this message for a trusted client!"
-)
-
-func getHex10FromUint64(value uint64) string {
-	v := hexutil.EncodeUint64(value)
-	v = strings.Replace(v, "0x", "", 1)
-
-	// Make sure result has fixed bytes
-	vBytes := []byte(v)
-	if len(vBytes) < 16 {
-		toAppend := make([]byte, 16-len(vBytes))
-		for i := range toAppend {
-			toAppend[i] = 48
-		}
-		vBytes = append(toAppend, vBytes...)
-	}
-
-	return fmt.Sprintf("0x%s", string(vBytes))
-}
-
-var _ TxInfo = (*L2ChangePubKeyTxInfo)(nil)
-
-type L2ChangePubKeyTxInfo struct {
-	AccountIndex int64
-	ApiKeyIndex  uint8
-
-	PubKey []byte
-	L1Sig  string
-
-	ExpiredAt  int64
-	Nonce      int64
-	Sig        []byte
-	SignedHash string `json:"-"`
-}
-
-func (txInfo *L2ChangePubKeyTxInfo) GetTxType() uint8 {
-	return TxTypeL2ChangePubKey
-}
-
-func (txInfo *L2ChangePubKeyTxInfo) GetTxInfo() (string, error) {
-	return getTxInfo(txInfo)
-}
-
-func (txInfo *L2ChangePubKeyTxInfo) GetTxHash() string {
-	return txInfo.SignedHash
-}
-
-func (txInfo *L2ChangePubKeyTxInfo) Validate() error {
-	// AccountIndex
-	if txInfo.AccountIndex < MinAccountIndex {
-		return ErrFromAccountIndexTooLow
-	}
-	if txInfo.AccountIndex > MaxAccountIndex {
-		return ErrFromAccountIndexTooHigh
-	}
-
-	// ApiKeyIndex
-	if txInfo.ApiKeyIndex < MinApiKeyIndex {
-		return ErrApiKeyIndexTooLow
-	}
-
-	if txInfo.ApiKeyIndex > MaxApiKeyIndex {
-		return ErrApiKeyIndexTooHigh
-	}
-
-	if txInfo.Nonce < MinNonce {
-		return ErrNonceTooLow
-	}
-
-	if txInfo.ExpiredAt < 0 || txInfo.ExpiredAt > MaxTimestamp {
-		return ErrExpiredAtInvalid
-	}
-
-	if !IsValidPubKey(txInfo.PubKey) {
-		return ErrPubKeyInvalid
-	}
-
-	return nil
-}
-
-func (txInfo *L2ChangePubKeyTxInfo) GetL1SignatureBody() string {
-	signatureBody := fmt.Sprintf(templateChangePubKey,
-		common.Bytes2Hex(txInfo.PubKey),
-		getHex10FromUint64(uint64(txInfo.Nonce)),
-		getHex10FromUint64(uint64(txInfo.AccountIndex)),
-		getHex10FromUint64(uint64(txInfo.ApiKeyIndex)),
-	)
-	return signatureBody
-}
-
-func (txInfo *L2ChangePubKeyTxInfo) Hash(lighterChainId uint32, extra ...g.Element) (msgHash []byte, err error) {
-	elems := make([]g.Element, 0, 11)
-
-	elems = append(elems, g.FromUint32(lighterChainId))
-	elems = append(elems, g.FromUint32(TxTypeL2ChangePubKey))
-	elems = append(elems, g.FromInt64(txInfo.Nonce))
-	elems = append(elems, g.FromInt64(txInfo.ExpiredAt))
-	elems = append(elems, g.FromInt64(txInfo.AccountIndex))
-	elems = append(elems, g.FromUint32(uint32(txInfo.ApiKeyIndex)))
-
-	pubKeyFieldElems, err := g.ArrayFromCanonicalLittleEndianBytes(txInfo.PubKey)
-	if err != nil {
-		return nil, fmt.Errorf("failed to convert bytes to field element. bytes: %v, error: %w", txInfo.PubKey, err)
-	}
-	elems = append(elems, pubKeyFieldElems...)
-
-	return p2.HashToQuinticExtension(elems).ToLittleEndianBytes(), nil
-}
@@ -1,175 +0,0 @@
-package txtypes
-
-import (
-	"math"
-
-	curve "github.com/elliottech/poseidon_crypto/curve/ecgfp5"
-	schnorr "github.com/elliottech/poseidon_crypto/signature/schnorr"
-)
-
-type (
-	Signature  = schnorr.Signature
-	PrivateKey = curve.ECgFp5Scalar
-)
-
-const (
-	NilApiKeyIndex = MaxApiKeyIndex + 1
-)
-
-const (
-	TxTypeL2ChangePubKey     = 8
-	TxTypeL2CreateSubAccount = 9
-	TxTypeL2CreatePublicPool = 10
-	TxTypeL2UpdatePublicPool = 11
-	TxTypeL2Transfer         = 12
-	TxTypeL2Withdraw         = 13
-	TxTypeL2CreateOrder      = 14
-	TxTypeL2CancelOrder      = 15
-	TxTypeL2CancelAllOrders  = 16
-	TxTypeL2ModifyOrder      = 17
-	TxTypeL2MintShares       = 18
-	TxTypeL2BurnShares       = 19
-	TxTypeL2UpdateLeverage   = 20
-
-	TxTypeInternalClaimOrder        = 21
-	TxTypeInternalCancelOrder       = 22
-	TxTypeInternalDeleverage        = 23
-	TxTypeInternalExitPosition      = 24
-	TxTypeInternalCancelAllOrders   = 25
-	TxTypeInternalLiquidatePosition = 26
-	TxTypeInternalCreateOrder       = 27
-
-	TxTypeL2CreateGroupedOrders = 28
-	TxTypeL2UpdateMargin        = 29
-)
-
-// Order Type
-const (
-	// User set order types
-	LimitOrder           = iota
-	MarketOrder          = 1
-	StopLossOrder        = 2
-	StopLossLimitOrder   = 3
-	TakeProfitOrder      = 4
-	TakeProfitLimitOrder = 5
-	TWAPOrder            = 6
-
-	// Internal order types
-	TWAPSubOrder     = 7
-	LiquidationOrder = 8
-
-	ApiMaxOrderType = TWAPOrder
-)
-
-// Order Time-In-Force
-const (
-	ImmediateOrCancel = iota
-	GoodTillTime      = 1
-	PostOnly          = 2
-)
-
-// Grouping Type
-const (
-	GroupingType                                = 0
-	GroupingType_OneTriggersTheOther            = 1
-	GroupingType_OneCancelsTheOther             = 2
-	GroupingType_OneTriggersAOneCancelsTheOther = 3
-)
-
-// Cancel All Orders Time-In-Force
-const (
-	ImmediateCancelAll      = iota
-	ScheduledCancelAll      = 1
-	AbortScheduledCancelAll = 2
-)
-
-const (
-	HashLength int = 32
-
-	OneUSDC = 1000000
-
-	FeeTick            int64 = 1_000_000
-	MarginFractionTick int64 = 10_000
-	ShareTick          int64 = 10_000
-
-	MinAccountIndex       int64 = 0
-	MaxAccountIndex       int64 = 281474976710654 // (1 << 48) - 2
-	MinApiKeyIndex        uint8 = 0
-	MaxApiKeyIndex        uint8 = 254             // (1 << 8) - 2
-	MaxMasterAccountIndex int64 = 140737488355327 // (1 << 47) - 1
-
-	MinMarketIndex uint8 = 0
-	MaxMarketIndex uint8 = 254 // (1 << 8) - 2
-
-	MaxInvestedPublicPoolCount int64 = 16
-	InitialPoolShareValue      int64 = 1_000                                             // 0.001 USDC
-	MinInitialTotalShares      int64 = 1_000 * (OneUSDC / InitialPoolShareValue)         // 1,000 USDC worth of shares
-	MaxInitialTotalShares      int64 = 1_000_000_000 * (OneUSDC / InitialPoolShareValue) // 1,000,000,000 USDC worth of shares
-	MaxPoolShares              int64 = (1 << 60) - 1
-	MaxBurntShareUSDCValue     int64 = (1 << 60) - 1
-
-	MaxPoolEntryUSDC                = (1 << 56) - 1 // 2^56 - 1 max USDC to invest in a pool
-	MinPoolSharesToMintOrBurn int64 = 1
-	MaxPoolSharesToMintOrBurn int64 = (1 << 60) - 1
-
-	MinNonce int64 = 0
-
-	MinOrderNonce int64 = 0
-	MaxOrderNonce int64 = (1 << 48) - 1
-
-	NilClientOrderIndex int64 = 0
-	NilOrderIndex       int64 = 0
-
-	MinClientOrderIndex int64 = 1
-	MaxClientOrderIndex int64 = (1 << 48) - 1
-
-	MinOrderIndex int64 = MaxClientOrderIndex + 1
-	MaxOrderIndex int64 = (1 << 56) - 1
-
-	MinOrderBaseAmount int64 = 1
-	MaxOrderBaseAmount int64 = (1 << 48) - 1
-	NilOrderBaseAmount int64 = 0
-
-	NilOrderPrice uint32 = 0
-	MinOrderPrice uint32 = 1
-	MaxOrderPrice uint32 = (1 << 32) - 1
-
-	MinOrderCancelAllPeriod int64 = 1000 * 60 * 5            // 5 minutes
-	MaxOrderCancelAllPeriod int64 = 1000 * 60 * 60 * 24 * 15 // 15 days
-
-	NilOrderExpiry int64 = 0
-	MinOrderExpiry int64 = 1
-	MaxOrderExpiry int64 = math.MaxInt64
-
-	MinOrderExpiryPeriod int64 = 1000 * 60 * 5            // 5 minutes
-	MaxOrderExpiryPeriod int64 = 1000 * 60 * 60 * 24 * 30 // 30 days
-
-	NilOrderTriggerPrice uint32 = 0
-	MinOrderTriggerPrice uint32 = 1
-	MaxOrderTriggerPrice uint32 = (1 << 32) - 1
-
-	MaxGroupedOrderCount int64 = 3
-
-	MaxTimestamp = (1 << 48) - 1
-)
-
-const (
-	MaxExchangeUSDC = (1 << 60) - 1
-
-	MinTransferAmount int64 = 1
-	MaxTransferAmount int64 = MaxExchangeUSDC
-
-	MinWithdrawalAmount uint64 = 1
-	MaxWithdrawalAmount uint64 = MaxExchangeUSDC
-)
-
-// Margin Modes
-const (
-	CrossMargin    = iota
-	IsolatedMargin = 1
-)
-
-const (
-	RemoveFromIsolatedMargin = 0
-	AddToIsolatedMargin      = 1
-)
@@ -1,336 +0,0 @@
-package txtypes
-
-import (
-	g "github.com/elliottech/poseidon_crypto/field/goldilocks"
-	p2 "github.com/elliottech/poseidon_crypto/hash/poseidon2_goldilocks"
-)
-
-var _ TxInfo = (*L2CreateGroupedOrdersTxInfo)(nil)
-
-// !!! Ensure that if primary order is reduce only, all child orders are also reduce only
-// !!! Otherwise CancelPositionTiedAccountOrders flow breaks
-type L2CreateGroupedOrdersTxInfo struct {
-	AccountIndex int64
-	ApiKeyIndex  uint8
-	GroupingType uint8
-
-	Orders []*OrderInfo
-
-	ExpiredAt  int64
-	Nonce      int64
-	Sig        []byte
-	SignedHash string `json:"-"`
-}
-
-func (txInfo *L2CreateGroupedOrdersTxInfo) GetTxType() uint8 {
-	return TxTypeL2CreateGroupedOrders
-}
-
-func (txInfo *L2CreateGroupedOrdersTxInfo) GetTxInfo() (string, error) {
-	return getTxInfo(txInfo)
-}
-
-func (txInfo *L2CreateGroupedOrdersTxInfo) GetTxHash() string {
-	return txInfo.SignedHash
-}
-
-func (txInfo *L2CreateGroupedOrdersTxInfo) Validate() error {
-	// AccountIndex
-	if txInfo.AccountIndex < MinAccountIndex {
-		return ErrAccountIndexTooLow
-	}
-	if txInfo.AccountIndex > MaxAccountIndex {
-		return ErrAccountIndexTooHigh
-	}
-	// ApiKeyIndex
-	if txInfo.ApiKeyIndex < MinApiKeyIndex {
-		return ErrApiKeyIndexTooLow
-	}
-	if txInfo.ApiKeyIndex > MaxApiKeyIndex {
-		return ErrApiKeyIndexTooHigh
-	}
-
-	if len(txInfo.Orders) == 0 || len(txInfo.Orders) > int(MaxGroupedOrderCount) {
-		return ErrOrderGroupSizeInvalid
-	}
-
-	// MarketIndex for first order
-	if txInfo.Orders[0].MarketIndex < MinMarketIndex {
-		return ErrMarketIndexTooLow
-	}
-	if txInfo.Orders[0].MarketIndex > MaxMarketIndex {
-		return ErrMarketIndexTooHigh
-	}
-
-	// Perform range checks for all orders
-	for _, order := range txInfo.Orders {
-		// MarketIndex
-		if order.MarketIndex != txInfo.Orders[0].MarketIndex {
-			return ErrMarketIndexMismatch
-		}
-
-		// ClientOrderIndex
-		if order.ClientOrderIndex != NilClientOrderIndex {
-			return ErrClientOrderIndexNotNil
-		}
-
-		// BaseAmount
-		if order.ReduceOnly != 1 && order.BaseAmount == NilOrderBaseAmount {
-			return ErrBaseAmountTooLow
-		}
-		if order.BaseAmount != NilOrderBaseAmount && order.BaseAmount < MinOrderBaseAmount {
-			return ErrBaseAmountTooLow
-		}
-		if order.BaseAmount > MaxOrderBaseAmount {
-			return ErrBaseAmountTooHigh
-		}
-
-		// Price
-		if order.Price < MinOrderPrice {
-			return ErrPriceTooLow
-		}
-		if order.Price > MaxOrderPrice {
-			return ErrPriceTooHigh
-		}
-
-		// IsAsk
-		if order.IsAsk != 0 && order.IsAsk != 1 {
-			return ErrIsAskInvalid
-		}
-
-		// TimeInForce
-		if order.TimeInForce != ImmediateOrCancel && order.TimeInForce != GoodTillTime && order.TimeInForce != PostOnly {
-			return ErrOrderTimeInForceInvalid
-		}
-
-		// ReduceOnly
-		if order.ReduceOnly != 0 && order.ReduceOnly != 1 {
-			return ErrOrderReduceOnlyInvalid
-		}
-
-		// OrderExpiry
-		if (order.OrderExpiry < MinOrderExpiry || order.OrderExpiry > MaxOrderExpiry) && order.OrderExpiry != NilOrderExpiry {
-			return ErrOrderExpiryInvalid
-		}
-
-		// TriggerPrice
-		if (order.TriggerPrice < MinOrderTriggerPrice || order.TriggerPrice > MaxOrderTriggerPrice) && order.TriggerPrice != NilOrderTriggerPrice {
-			return ErrOrderTriggerPriceInvalid
-		}
-	}
-
-	// Nonce
-	if txInfo.Nonce < MinNonce {
-		return ErrNonceTooLow
-	}
-
-	if txInfo.ExpiredAt < 0 || txInfo.ExpiredAt > MaxTimestamp {
-		return ErrExpiredAtInvalid
-	}
-
-	switch txInfo.GroupingType {
-	case GroupingType_OneCancelsTheOther:
-		return txInfo.ValidateOCO()
-	case GroupingType_OneTriggersTheOther:
-		return txInfo.ValidateOTO()
-	case GroupingType_OneTriggersAOneCancelsTheOther:
-		return txInfo.ValidateOTOCO()
-	default:
-		return ErrGroupingTypeInvalid
-	}
-}
-
-func (txInfo *L2CreateGroupedOrdersTxInfo) ValidateParentOrder(order *OrderInfo) error {
-	switch order.Type {
-	case MarketOrder:
-		if order.TimeInForce != ImmediateOrCancel {
-			return ErrOrderTimeInForceInvalid
-		} else if order.OrderExpiry != NilOrderExpiry {
-			return ErrOrderExpiryInvalid
-		} else if order.TriggerPrice != NilOrderTriggerPrice {
-			return ErrOrderTriggerPriceInvalid
-		}
-	case LimitOrder:
-		if order.TriggerPrice != NilOrderTriggerPrice {
-			return ErrOrderTriggerPriceInvalid
-		} else if order.TimeInForce == ImmediateOrCancel && order.OrderExpiry != NilOrderExpiry {
-			return ErrOrderExpiryInvalid
-		} else if order.TimeInForce != ImmediateOrCancel && order.OrderExpiry == NilOrderExpiry {
-			return ErrOrderExpiryInvalid
-		}
-	default:
-		return ErrOrderTypeInvalid
-	}
-	return nil
-}
-
-func (txInfo *L2CreateGroupedOrdersTxInfo) ValidateChildOrder(order *OrderInfo) error {
-	switch order.Type {
-	case StopLossOrder, TakeProfitOrder:
-		if order.TimeInForce != ImmediateOrCancel {
-			return ErrOrderTimeInForceInvalid
-		} else if order.TriggerPrice == NilOrderTriggerPrice {
-			return ErrOrderTriggerPriceInvalid
-		} else if order.OrderExpiry == NilOrderExpiry {
-			return ErrOrderExpiryInvalid
-		}
-	case StopLossLimitOrder, TakeProfitLimitOrder:
-		if order.TriggerPrice == NilOrderTriggerPrice {
-			return ErrOrderTriggerPriceInvalid
-		} else if order.OrderExpiry == NilOrderExpiry {
-			return ErrOrderExpiryInvalid
-		}
-	default:
-		return ErrOrderTypeInvalid
-	}
-	return nil
-}
-
-func (txInfo *L2CreateGroupedOrdersTxInfo) ValidateSiblingOrders(orders []*OrderInfo) error {
-	if len(orders) != 2 {
-		return ErrOrderGroupSizeInvalid
-	}
-	slFlag := false
-	tpFlag := false
-	for _, order := range orders {
-		err := txInfo.ValidateChildOrder(order)
-		if err != nil {
-			return err
-		}
-		if order.Type == StopLossOrder || order.Type == StopLossLimitOrder {
-			slFlag = true
-		} else if order.Type == TakeProfitOrder || order.Type == TakeProfitLimitOrder {
-			tpFlag = true
-		}
-	}
-	if !slFlag || !tpFlag {
-		return ErrOrderTypeInvalid
-	}
-	return nil
-}
-
-func (txInfo *L2CreateGroupedOrdersTxInfo) ValidateOCO() error {
-	if len(txInfo.Orders) != 2 {
-		return ErrOrderGroupSizeInvalid
-	}
-
-	// Ensure both orders base sizes are same
-	if txInfo.Orders[0].BaseAmount != txInfo.Orders[1].BaseAmount {
-		return ErrBaseAmountsNotEqual
-	}
-
-	// Orders should be in the same direction
-	if txInfo.Orders[0].IsAsk != txInfo.Orders[1].IsAsk {
-		return ErrIsAskInvalid
-	}
-
-	// Ensure both orders are reduce only
-	if txInfo.Orders[0].ReduceOnly != 1 || txInfo.Orders[1].ReduceOnly != 1 {
-		return ErrOrderReduceOnlyInvalid
-	}
-
-	// Ensure both orders have the same non-nil expiry
-	if txInfo.Orders[0].OrderExpiry != txInfo.Orders[1].OrderExpiry {
-		return ErrOrderExpiryInvalid
-	}
-
-	return txInfo.ValidateSiblingOrders(txInfo.Orders)
-}
-
-func (txInfo *L2CreateGroupedOrdersTxInfo) ValidateOTO() error {
-	if len(txInfo.Orders) != 2 {
-		return ErrOrderGroupSizeInvalid
-	}
-
-	// Ensure child order base size is 0
-	if txInfo.Orders[1].BaseAmount != NilOrderBaseAmount {
-		return ErrBaseAmountNotNil
-	}
-
-	// Orders should be in the opposite direction
-	if txInfo.Orders[0].IsAsk == txInfo.Orders[1].IsAsk {
-		return ErrIsAskInvalid
-	}
-
-	// Ensure if expiries are not nil, they are the same
-	if txInfo.Orders[0].OrderExpiry != NilOrderExpiry &&
-		txInfo.Orders[0].OrderExpiry != txInfo.Orders[1].OrderExpiry {
-		return ErrOrderExpiryInvalid
-	}
-
-	err := txInfo.ValidateParentOrder(txInfo.Orders[0])
-	if err != nil {
-		return err
-	}
-
-	return txInfo.ValidateChildOrder(txInfo.Orders[1])
-}
-
-func (txInfo *L2CreateGroupedOrdersTxInfo) ValidateOTOCO() error {
-	if len(txInfo.Orders) != 3 {
-		return ErrOrderGroupSizeInvalid
-	}
-
-	// Ensure child orders base size is 0
-	if txInfo.Orders[1].BaseAmount != NilOrderBaseAmount || txInfo.Orders[2].BaseAmount != NilOrderBaseAmount {
-		return ErrBaseAmountNotNil
-	}
-
-	// Primary and child orders should be in the oppsite direction
-	if txInfo.Orders[0].IsAsk == txInfo.Orders[1].IsAsk || txInfo.Orders[0].IsAsk == txInfo.Orders[2].IsAsk {
-		return ErrIsAskInvalid
-	}
-
-	// Ensure child orders has the same expiry
-	if txInfo.Orders[1].OrderExpiry != txInfo.Orders[2].OrderExpiry {
-		return ErrOrderExpiryInvalid
-	}
-
-	// Ensure if expiries are not nil, they are the same
-	if txInfo.Orders[0].OrderExpiry != NilOrderExpiry &&
-		txInfo.Orders[0].OrderExpiry != txInfo.Orders[1].OrderExpiry {
-		return ErrOrderExpiryInvalid
-	}
-
-	err := txInfo.ValidateParentOrder(txInfo.Orders[0])
-	if err != nil {
-		return err
-	}
-	return txInfo.ValidateSiblingOrders(txInfo.Orders[1:])
-}
-
-func (txInfo *L2CreateGroupedOrdersTxInfo) Hash(lighterChainId uint32, extra ...g.Element) (msgHash []byte, err error) {
-	elems := make([]g.Element, 0, 11)
-	elems = append(elems, g.FromUint32(lighterChainId))
-	elems = append(elems, g.FromUint32(TxTypeL2CreateGroupedOrders))
-	elems = append(elems, g.FromInt64(txInfo.Nonce))
-	elems = append(elems, g.FromInt64(txInfo.ExpiredAt))
-
-	elems = append(elems, g.FromInt64(txInfo.AccountIndex))
-	elems = append(elems, g.FromUint32(uint32(txInfo.ApiKeyIndex)))
-	elems = append(elems, g.FromUint32(uint32(txInfo.GroupingType)))
-
-	aggregatedOrderHash := p2.EmptyHashOut()
-	for index, order := range txInfo.Orders {
-		orderHash := p2.HashNoPad([]g.Element{
-			g.FromUint32(uint32(order.MarketIndex)),
-			g.FromInt64(order.ClientOrderIndex),
-			g.FromInt64(order.BaseAmount),
-			g.FromUint32(order.Price),
-			g.FromUint32(uint32(order.IsAsk)),
-			g.FromUint32(uint32(order.Type)),
-			g.FromUint32(uint32(order.TimeInForce)),
-			g.FromUint32(uint32(order.ReduceOnly)),
-			g.FromUint32(order.TriggerPrice),
-			g.FromInt64(order.OrderExpiry),
-		})
-		if index == 0 {
-			aggregatedOrderHash = orderHash
-		} else {
-			aggregatedOrderHash = p2.HashNToOne([]p2.HashOut{aggregatedOrderHash, orderHash})
-		}
-	}
-	elems = append(elems, aggregatedOrderHash[:]...)
-
-	return p2.HashToQuinticExtension(elems).ToLittleEndianBytes(), nil
-}
@@ -1,186 +0,0 @@
-package txtypes
-
-import (
-	g "github.com/elliottech/poseidon_crypto/field/goldilocks"
-	p2 "github.com/elliottech/poseidon_crypto/hash/poseidon2_goldilocks"
-)
-
-var _ TxInfo = (*L2CreateOrderTxInfo)(nil)
-
-type L2CreateOrderTxInfo struct {
-	AccountIndex int64
-	ApiKeyIndex  uint8
-
-	*OrderInfo
-
-	ExpiredAt  int64
-	Nonce      int64
-	Sig        []byte
-	SignedHash string `json:"-"`
-}
-
-func (txInfo *L2CreateOrderTxInfo) GetTxType() uint8 {
-	return TxTypeL2CreateOrder
-}
-
-func (txInfo *L2CreateOrderTxInfo) GetTxInfo() (string, error) {
-	return getTxInfo(txInfo)
-}
-
-func (txInfo *L2CreateOrderTxInfo) GetTxHash() string {
-	return txInfo.SignedHash
-}
-
-func (txInfo *L2CreateOrderTxInfo) Validate() error {
-	// AccountIndex
-	if txInfo.AccountIndex < MinAccountIndex {
-		return ErrAccountIndexTooLow
-	}
-	if txInfo.AccountIndex > MaxAccountIndex {
-		return ErrAccountIndexTooHigh
-	}
-	// ApiKeyIndex
-	if txInfo.ApiKeyIndex < MinApiKeyIndex {
-		return ErrApiKeyIndexTooLow
-	}
-	if txInfo.ApiKeyIndex > MaxApiKeyIndex {
-		return ErrApiKeyIndexTooHigh
-	}
-
-	// MarketIndex
-	if txInfo.MarketIndex < MinMarketIndex {
-		return ErrMarketIndexTooLow
-	}
-	if txInfo.MarketIndex > MaxMarketIndex {
-		return ErrMarketIndexTooHigh
-	}
-
-	// ClientOrderIndex
-	if txInfo.ClientOrderIndex != NilClientOrderIndex {
-		if txInfo.ClientOrderIndex < MinClientOrderIndex {
-			return ErrClientOrderIndexTooLow
-		}
-		if txInfo.ClientOrderIndex > MaxClientOrderIndex {
-			return ErrClientOrderIndexTooHigh
-		}
-	}
-
-	// BaseAmount
-	if txInfo.ReduceOnly != 1 && txInfo.BaseAmount == NilOrderBaseAmount {
-		return ErrBaseAmountTooLow
-	}
-	if txInfo.BaseAmount != NilOrderBaseAmount && txInfo.BaseAmount < MinOrderBaseAmount {
-		return ErrBaseAmountTooLow
-	}
-	if txInfo.BaseAmount > MaxOrderBaseAmount {
-		return ErrBaseAmountTooHigh
-	}
-
-	// Price
-	if txInfo.Price < MinOrderPrice {
-		return ErrPriceTooLow
-	}
-	if txInfo.Price > MaxOrderPrice {
-		return ErrPriceTooHigh
-	}
-
-	// IsAsk
-	if txInfo.IsAsk != 0 && txInfo.IsAsk != 1 {
-		return ErrIsAskInvalid
-	}
-
-	if txInfo.TimeInForce != ImmediateOrCancel && txInfo.TimeInForce != GoodTillTime && txInfo.TimeInForce != PostOnly {
-		return ErrOrderTimeInForceInvalid
-	}
-
-	if txInfo.ReduceOnly != 0 && txInfo.ReduceOnly != 1 {
-		return ErrOrderReduceOnlyInvalid
-	}
-
-	if (txInfo.OrderExpiry < MinOrderExpiry || txInfo.OrderExpiry > MaxOrderExpiry) && txInfo.OrderExpiry != NilOrderExpiry {
-		return ErrOrderExpiryInvalid
-	}
-
-	switch txInfo.Type {
-	case MarketOrder:
-		if txInfo.TimeInForce != ImmediateOrCancel {
-			return ErrOrderTimeInForceInvalid
-		} else if txInfo.OrderExpiry != NilOrderExpiry {
-			return ErrOrderExpiryInvalid
-		} else if txInfo.TriggerPrice != NilOrderTriggerPrice {
-			return ErrOrderTriggerPriceInvalid
-		}
-	case LimitOrder:
-		if txInfo.TriggerPrice != NilOrderTriggerPrice {
-			return ErrOrderTriggerPriceInvalid
-		} else if txInfo.TimeInForce == ImmediateOrCancel && txInfo.OrderExpiry != NilOrderExpiry {
-			return ErrOrderExpiryInvalid
-		} else if txInfo.TimeInForce != ImmediateOrCancel && txInfo.OrderExpiry == NilOrderExpiry {
-			return ErrOrderExpiryInvalid
-		}
-	case StopLossOrder, TakeProfitOrder:
-		if txInfo.TimeInForce != ImmediateOrCancel {
-			return ErrOrderTimeInForceInvalid
-		} else if txInfo.TriggerPrice == NilOrderTriggerPrice {
-			return ErrOrderTriggerPriceInvalid
-		} else if txInfo.OrderExpiry == NilOrderExpiry {
-			return ErrOrderExpiryInvalid
-		}
-	case StopLossLimitOrder, TakeProfitLimitOrder:
-		if txInfo.TriggerPrice == NilOrderTriggerPrice {
-			return ErrOrderTriggerPriceInvalid
-		} else if txInfo.OrderExpiry == NilOrderExpiry {
-			return ErrOrderExpiryInvalid
-		}
-	case TWAPOrder:
-		if txInfo.TimeInForce != GoodTillTime {
-			return ErrOrderTimeInForceInvalid
-		} else if txInfo.TriggerPrice != NilOrderTriggerPrice {
-			return ErrOrderTriggerPriceInvalid
-		} else if txInfo.OrderExpiry == NilOrderExpiry {
-			return ErrOrderExpiryInvalid
-		}
-	default:
-		return ErrOrderTypeInvalid
-	}
-
-	// TriggerPrice
-	if (txInfo.TriggerPrice < MinOrderTriggerPrice || txInfo.TriggerPrice > MaxOrderTriggerPrice) && txInfo.TriggerPrice != NilOrderTriggerPrice {
-		return ErrOrderTriggerPriceInvalid
-	}
-
-	// Nonce
-	if txInfo.Nonce < MinNonce {
-		return ErrNonceTooLow
-	}
-
-	if txInfo.ExpiredAt < 0 || txInfo.ExpiredAt > MaxTimestamp {
-		return ErrExpiredAtInvalid
-	}
-
-	return nil
-}
-
-func (txInfo *L2CreateOrderTxInfo) Hash(lighterChainId uint32, extra ...g.Element) (msgHash []byte, err error) {
-	elems := make([]g.Element, 0, 16)
-
-	elems = append(elems, g.FromUint32(lighterChainId))
-	elems = append(elems, g.FromUint32(TxTypeL2CreateOrder))
-	elems = append(elems, g.FromInt64(txInfo.Nonce))
-	elems = append(elems, g.FromInt64(txInfo.ExpiredAt))
-
-	elems = append(elems, g.FromInt64(txInfo.AccountIndex))
-	elems = append(elems, g.FromUint32(uint32(txInfo.ApiKeyIndex)))
-	elems = append(elems, g.FromUint32(uint32(txInfo.MarketIndex)))
-	elems = append(elems, g.FromInt64(txInfo.ClientOrderIndex))
-	elems = append(elems, g.FromInt64(txInfo.BaseAmount))
-	elems = append(elems, g.FromUint32(txInfo.Price))
-	elems = append(elems, g.FromUint32(uint32(txInfo.IsAsk)))
-	elems = append(elems, g.FromUint32(uint32(txInfo.Type)))
-	elems = append(elems, g.FromUint32(uint32(txInfo.TimeInForce)))
-	elems = append(elems, g.FromUint32(uint32(txInfo.ReduceOnly)))
-	elems = append(elems, g.FromUint32(txInfo.TriggerPrice))
-	elems = append(elems, g.FromInt64(txInfo.OrderExpiry))
-
-	return p2.HashToQuinticExtension(elems).ToLittleEndianBytes(), nil
-}
@@ -1,101 +0,0 @@
-package txtypes
-
-import (
-	g "github.com/elliottech/poseidon_crypto/field/goldilocks"
-	p2 "github.com/elliottech/poseidon_crypto/hash/poseidon2_goldilocks"
-)
-
-var _ TxInfo = (*L2CreatePublicPoolTxInfo)(nil)
-
-type L2CreatePublicPoolTxInfo struct {
-	AccountIndex int64 // Master account index
-	ApiKeyIndex  uint8
-
-	OperatorFee          int64
-	InitialTotalShares   int64
-	MinOperatorShareRate int64
-
-	ExpiredAt  int64
-	Nonce      int64
-	Sig        []byte
-	SignedHash string `json:"-"`
-}
-
-func (txInfo *L2CreatePublicPoolTxInfo) GetTxType() uint8 {
-	return TxTypeL2CreatePublicPool
-}
-
-func (txInfo *L2CreatePublicPoolTxInfo) GetTxInfo() (string, error) {
-	return getTxInfo(txInfo)
-}
-
-func (txInfo *L2CreatePublicPoolTxInfo) GetTxHash() string {
-	return txInfo.SignedHash
-}
-
-func (txInfo *L2CreatePublicPoolTxInfo) Validate() error {
-	// AccountIndex
-	if txInfo.AccountIndex < MinAccountIndex {
-		return ErrFromAccountIndexTooLow
-	}
-	if txInfo.AccountIndex > MaxMasterAccountIndex {
-		return ErrFromAccountIndexTooHigh
-	}
-
-	// ApiKeyIndex
-	if txInfo.ApiKeyIndex < MinApiKeyIndex {
-		return ErrApiKeyIndexTooLow
-	}
-	if txInfo.ApiKeyIndex > MaxApiKeyIndex {
-		return ErrApiKeyIndexTooHigh
-	}
-
-	// OperatorFee
-	if txInfo.OperatorFee < 0 || txInfo.OperatorFee > FeeTick {
-		return ErrInvalidPoolOperatorFee
-	}
-
-	// InitialTotalShares
-	if txInfo.InitialTotalShares <= 0 {
-		return ErrPoolInitialTotalSharesTooLow
-	}
-	if txInfo.InitialTotalShares > MaxInitialTotalShares {
-		return ErrPoolInitialTotalSharesTooHigh
-	}
-
-	// MinOperatorShareRate
-	if txInfo.MinOperatorShareRate < 0 {
-		return ErrPoolMinOperatorShareRateTooLow
-	}
-	if txInfo.MinOperatorShareRate > ShareTick {
-		return ErrPoolMinOperatorShareRateTooHigh
-	}
-
-	// Nonce
-	if txInfo.Nonce < MinNonce {
-		return ErrNonceTooLow
-	}
-
-	if txInfo.ExpiredAt < 0 || txInfo.ExpiredAt > MaxTimestamp {
-		return ErrExpiredAtInvalid
-	}
-
-	return nil
-}
-
-func (txInfo *L2CreatePublicPoolTxInfo) Hash(lighterChainId uint32, extra ...g.Element) (msgHash []byte, err error) {
-	elems := make([]g.Element, 0, 9)
-
-	elems = append(elems, g.FromUint32(lighterChainId))
-	elems = append(elems, g.FromUint32(TxTypeL2CreatePublicPool))
-	elems = append(elems, g.FromInt64(txInfo.Nonce))
-	elems = append(elems, g.FromInt64(txInfo.ExpiredAt))
-
-	elems = append(elems, g.FromInt64(txInfo.AccountIndex))
-	elems = append(elems, g.FromUint32(uint32(txInfo.ApiKeyIndex)))
-	elems = append(elems, g.FromInt64(txInfo.OperatorFee))
-	elems = append(elems, g.FromInt64(txInfo.InitialTotalShares))
-	elems = append(elems, g.FromInt64(txInfo.MinOperatorShareRate))
-
-	return p2.HashToQuinticExtension(elems).ToLittleEndianBytes(), nil
-}
@@ -1,73 +0,0 @@
-package txtypes
-
-import (
-	g "github.com/elliottech/poseidon_crypto/field/goldilocks"
-	p2 "github.com/elliottech/poseidon_crypto/hash/poseidon2_goldilocks"
-)
-
-var _ TxInfo = (*L2CreateSubAccountTxInfo)(nil)
-
-type L2CreateSubAccountTxInfo struct {
-	AccountIndex int64 // Master account index
-	ApiKeyIndex  uint8
-
-	ExpiredAt  int64
-	Nonce      int64
-	Sig        []byte
-	SignedHash string `json:"-"`
-}
-
-func (txInfo *L2CreateSubAccountTxInfo) GetTxType() uint8 {
-	return TxTypeL2CreateSubAccount
-}
-
-func (txInfo *L2CreateSubAccountTxInfo) GetTxInfo() (string, error) {
-	return getTxInfo(txInfo)
-}
-
-func (txInfo *L2CreateSubAccountTxInfo) GetTxHash() string {
-	return txInfo.SignedHash
-}
-
-func (txInfo *L2CreateSubAccountTxInfo) Validate() error {
-	// AccountIndex
-	if txInfo.AccountIndex < MinAccountIndex {
-		return ErrFromAccountIndexTooLow
-	}
-	if txInfo.AccountIndex > MaxAccountIndex {
-		return ErrFromAccountIndexTooHigh
-	}
-
-	// ApiKeyIndex
-	if txInfo.ApiKeyIndex < MinApiKeyIndex {
-		return ErrApiKeyIndexTooLow
-	}
-	if txInfo.ApiKeyIndex > MaxApiKeyIndex {
-		return ErrApiKeyIndexTooHigh
-	}
-
-	// Nonce
-	if txInfo.Nonce < MinNonce {
-		return ErrNonceTooLow
-	}
-
-	if txInfo.ExpiredAt < 0 || txInfo.ExpiredAt > MaxTimestamp {
-		return ErrExpiredAtInvalid
-	}
-
-	return nil
-}
-
-func (txInfo *L2CreateSubAccountTxInfo) Hash(lighterChainId uint32, extra ...g.Element) (msgHash []byte, err error) {
-	elems := make([]g.Element, 0, 6)
-
-	elems = append(elems, g.FromUint32(lighterChainId))
-	elems = append(elems, g.FromUint32(TxTypeL2CreateSubAccount))
-	elems = append(elems, g.FromInt64(txInfo.Nonce))
-	elems = append(elems, g.FromInt64(txInfo.ExpiredAt))
-
-	elems = append(elems, g.FromInt64(txInfo.AccountIndex))
-	elems = append(elems, g.FromUint32(uint32(txInfo.ApiKeyIndex)))
-
-	return p2.HashToQuinticExtension(elems).ToLittleEndianBytes(), nil
-}
@@ -1,66 +0,0 @@
-package txtypes
-
-import "fmt"
-
-var (
-	ErrAccountIndexTooLow              = fmt.Errorf("AccountIndex should not be less than %d", MinAccountIndex)
-	ErrAccountIndexTooHigh             = fmt.Errorf("AccountIndex should not be larger than %d", MaxAccountIndex)
-	ErrNonceTooLow                     = fmt.Errorf("AccountNonce should not be less than %d", MinNonce)
-	ErrInvalidCancelAllTimeInForce     = fmt.Errorf("CancelAllTimeInForce is invalid")
-	ErrOrderReduceOnlyInvalid          = fmt.Errorf("ReduceOnly is invalid")
-	ErrOrderTriggerPriceInvalid        = fmt.Errorf("TriggerPrice is invalid")
-	ErrOrderExpiryInvalid              = fmt.Errorf("OrderExpiry is invalid")
-	ErrExpiredAtInvalid                = fmt.Errorf("ExpiredAt is invalid")
-	ErrCancelAllTimeIsNotInRange       = fmt.Errorf("CancelAllTime should be larger than 0 and not larger than %d", MaxOrderExpiry)
-	ErrCancelAllTimeisNotNill          = fmt.Errorf("CancelAllTime should be nil")
-	ErrPubKeyInvalid                   = fmt.Errorf("PubKey is invalid")
-	ErrToAccountIndexTooLow            = fmt.Errorf("ToAccountIndex should not be less than %d", MinAccountIndex)
-	ErrToAccountIndexTooHigh           = fmt.Errorf("ToAccountIndex should not be larger than %d", MaxAccountIndex)
-	ErrFromAccountIndexTooLow          = fmt.Errorf("FromAccountIndex should not be less than %d", MinAccountIndex)
-	ErrFromAccountIndexTooHigh         = fmt.Errorf("FromAccountIndex should not be larger than %d", MaxAccountIndex)
-	ErrApiKeyIndexTooLow               = fmt.Errorf("ApiKeyIndex should not be less than %d", MinApiKeyIndex)
-	ErrApiKeyIndexTooHigh              = fmt.Errorf("ApiKeyIndex should not be larger than %d", MaxApiKeyIndex)
-	ErrPublicPoolIndexTooLow           = fmt.Errorf("PublicPoolIndex should not be less than %d", MinAccountIndex)
-	ErrPublicPoolIndexTooHigh          = fmt.Errorf("PublicPoolIndex should not be larger than %d", MaxAccountIndex)
-	ErrInvalidPoolOperatorFee          = fmt.Errorf("PoolOperatorFee should be larger than 0 and not larger than %d", FeeTick)
-	ErrInvalidPoolStatus               = fmt.Errorf("PoolStatus should be either 0 or 1")
-	ErrPoolInitialTotalSharesTooLow    = fmt.Errorf("PoolInitialTotalShares should be larger than %d", MinInitialTotalShares)
-	ErrPoolInitialTotalSharesTooHigh   = fmt.Errorf("PoolInitialTotalShares should not be larger than %d", MaxInitialTotalShares)
-	ErrPoolMinOperatorShareRateTooLow  = fmt.Errorf("PoolMinOperatorShareRate should be larger than 0")
-	ErrPoolMinOperatorShareRateTooHigh = fmt.Errorf("PoolMinOperatorShareRate should not be larger than %d", ShareTick)
-	ErrPoolMintShareAmountTooLow       = fmt.Errorf("PoolMintShareAmount should be larger than %d", MinPoolSharesToMintOrBurn)
-	ErrPoolMintShareAmountTooHigh      = fmt.Errorf("PoolMintShareAmount should not be larger than %d", MaxPoolSharesToMintOrBurn)
-	ErrPoolBurnShareAmountTooLow       = fmt.Errorf("PoolBurnShareAmount should be larger than %d", MinPoolSharesToMintOrBurn)
-	ErrPoolBurnShareAmountTooHigh      = fmt.Errorf("PoolBurnShareAmount should not be larger than %d", MaxPoolSharesToMintOrBurn)
-	ErrWithdrawalAmountTooLow          = fmt.Errorf("WithdrawalAmount should be larger than %d", MinWithdrawalAmount)
-	ErrWithdrawalAmountTooHigh         = fmt.Errorf("WithdrawalAmount should not be larger than %d", MaxWithdrawalAmount)
-	ErrTransferAmountTooLow            = fmt.Errorf("TransferAmount should be larger than %d", MinTransferAmount)
-	ErrTransferAmountTooHigh           = fmt.Errorf("TransferAmount should not be larger than %d", MaxTransferAmount)
-	ErrMarketIndexTooLow               = fmt.Errorf("MarketIndex should not be less than %d", MinMarketIndex)
-	ErrMarketIndexTooHigh              = fmt.Errorf("MarketIndex should not be larger than %d", MaxMarketIndex)
-	ErrMarketIndexMismatch             = fmt.Errorf("MarketIndex should match the market index of the order")
-	ErrInitialMarginFractionTooLow     = fmt.Errorf("InitialMarginFraction should not be less than %d", 0)
-	ErrInitialMarginFractionTooHigh    = fmt.Errorf("InitialMarginFraction should not be larger than %d", MarginFractionTick)
-	ErrClientOrderIndexTooLow          = fmt.Errorf("ClientOrderIndex should not be less than %d", MinClientOrderIndex)
-	ErrClientOrderIndexTooHigh         = fmt.Errorf("ClientOrderIndex should not be larger than %d", MaxClientOrderIndex)
-	ErrClientOrderIndexNotNil          = fmt.Errorf("ClientOrderIndex should be nil")
-	ErrOrderIndexTooLow                = fmt.Errorf("OrderIndex should not be less than %d", MinOrderIndex)
-	ErrOrderIndexTooHigh               = fmt.Errorf("OrderIndex should not be larger than %d", MaxOrderIndex)
-	ErrBaseAmountTooLow                = fmt.Errorf("BaseAmount should not be less than %d", MinOrderBaseAmount)
-	ErrBaseAmountTooHigh               = fmt.Errorf("BaseAmount should not be larger than %d", MaxOrderBaseAmount)
-	ErrBaseAmountsNotEqual             = fmt.Errorf("BaseAmounts should be equal")
-	ErrBaseAmountNotNil                = fmt.Errorf("BaseAmount should be nil")
-	ErrPriceTooLow                     = fmt.Errorf("OrderPrice should not be less than %d", MinOrderPrice)
-	ErrPriceTooHigh                    = fmt.Errorf("OrderPrice should not be larger than %d", MaxOrderPrice)
-	ErrIsAskInvalid                    = fmt.Errorf("IsAsk should be 0 or 1")
-	ErrOrderTypeInvalid                = fmt.Errorf("OrderType is not valid")
-	ErrOrderTimeInForceInvalid         = fmt.Errorf("OrderTimeInForce is not valid")
-	ErrGroupingTypeInvalid             = fmt.Errorf("GroupingType is not valid")
-	ErrOrderGroupSizeInvalid           = fmt.Errorf("OrderGroupSize is not valid")
-	ErrInvalidSignature                = fmt.Errorf("TxSignature is invalid")
-	ErrInvalidMarginMode               = fmt.Errorf("MarginMode is not valid")
-	ErrCancelModeInvalid               = fmt.Errorf("CancelMode is not valid")
-	ErrInvalidUpdateMarginDirection    = fmt.Errorf("Margin movement direction is not valid")
-	ErrTransferFeeNegative             = fmt.Errorf("Transfer fee is negative")
-	ErrTransferFeeTooHigh              = fmt.Errorf("Transfer fee is higher than %d", MaxTransferAmount)
-)
@@ -1,37 +0,0 @@
-package txtypes
-
-import g "github.com/elliottech/poseidon_crypto/field/goldilocks"
-
-type TxInfo interface {
-	GetTxType() uint8
-
-	GetTxInfo() (string, error)
-
-	// GetTxHash returns the hash that was signed when creating this transaction.
-	// The hash coincides with the TxHash received from Lighter after submitting this Tx.
-	// It can be used to get the TxHash in advance, or to double-check the correctness of the SDK.
-	// As this hash is signed by the ApiKey, if the value differs than the one computed by the server,
-	// it'll result in an invalid signature.
-	// Returns empty string if the Tx is not signed.
-	GetTxHash() string
-
-	Validate() error
-
-	Hash(lighterChainId uint32, extra ...g.Element) (msgHash []byte, err error)
-}
-
-type OrderInfo struct {
-	MarketIndex uint8
-
-	ClientOrderIndex int64
-
-	BaseAmount int64
-	Price      uint32
-	IsAsk      uint8
-
-	Type         uint8
-	TimeInForce  uint8
-	ReduceOnly   uint8
-	TriggerPrice uint32
-	OrderExpiry  int64
-}
@@ -1,91 +0,0 @@
-package txtypes
-
-import (
-	g "github.com/elliottech/poseidon_crypto/field/goldilocks"
-	p2 "github.com/elliottech/poseidon_crypto/hash/poseidon2_goldilocks"
-)
-
-var _ TxInfo = (*L2MintSharesTxInfo)(nil)
-
-type L2MintSharesTxInfo struct {
-	AccountIndex int64
-	ApiKeyIndex  uint8
-
-	PublicPoolIndex int64
-	ShareAmount     int64
-
-	ExpiredAt  int64
-	Nonce      int64
-	Sig        []byte
-	SignedHash string `json:"-"`
-}
-
-func (txInfo *L2MintSharesTxInfo) GetTxType() uint8 {
-	return TxTypeL2MintShares
-}
-
-func (txInfo *L2MintSharesTxInfo) GetTxInfo() (string, error) {
-	return getTxInfo(txInfo)
-}
-
-func (txInfo *L2MintSharesTxInfo) GetTxHash() string {
-	return txInfo.SignedHash
-}
-
-func (txInfo *L2MintSharesTxInfo) Validate() error {
-	if txInfo.AccountIndex < MinAccountIndex {
-		return ErrFromAccountIndexTooLow
-	}
-	if txInfo.AccountIndex > MaxAccountIndex {
-		return ErrFromAccountIndexTooHigh
-	}
-
-	// ApiKeyIndex
-	if txInfo.ApiKeyIndex < MinApiKeyIndex {
-		return ErrApiKeyIndexTooLow
-	}
-	if txInfo.ApiKeyIndex > MaxApiKeyIndex {
-		return ErrApiKeyIndexTooHigh
-	}
-
-	// PublicPoolIndex
-	if txInfo.PublicPoolIndex < MinAccountIndex {
-		return ErrPublicPoolIndexTooLow
-	}
-	if txInfo.PublicPoolIndex > MaxAccountIndex {
-		return ErrPublicPoolIndexTooHigh
-	}
-
-	if txInfo.ShareAmount < MinPoolSharesToMintOrBurn {
-		return ErrPoolMintShareAmountTooLow
-	}
-	if txInfo.ShareAmount > MaxPoolSharesToMintOrBurn {
-		return ErrPoolMintShareAmountTooHigh
-	}
-
-	if txInfo.Nonce < MinNonce {
-		return ErrNonceTooLow
-	}
-
-	if txInfo.ExpiredAt < 0 || txInfo.ExpiredAt > MaxTimestamp {
-		return ErrExpiredAtInvalid
-	}
-
-	return nil
-}
-
-func (txInfo *L2MintSharesTxInfo) Hash(lighterChainId uint32, extra ...g.Element) (msgHash []byte, err error) {
-	elems := make([]g.Element, 0, 8)
-
-	elems = append(elems, g.FromUint32(lighterChainId))
-	elems = append(elems, g.FromUint32(TxTypeL2MintShares))
-	elems = append(elems, g.FromInt64(txInfo.Nonce))
-	elems = append(elems, g.FromInt64(txInfo.ExpiredAt))
-
-	elems = append(elems, g.FromInt64(txInfo.AccountIndex))
-	elems = append(elems, g.FromUint32(uint32(txInfo.ApiKeyIndex)))
-	elems = append(elems, g.FromInt64(txInfo.PublicPoolIndex))
-	elems = append(elems, g.FromInt64(txInfo.ShareAmount))
-
-	return p2.HashToQuinticExtension(elems).ToLittleEndianBytes(), nil
-}
@@ -1,120 +0,0 @@
-package txtypes
-
-import (
-	g "github.com/elliottech/poseidon_crypto/field/goldilocks"
-	p2 "github.com/elliottech/poseidon_crypto/hash/poseidon2_goldilocks"
-)
-
-var _ TxInfo = (*L2ModifyOrderTxInfo)(nil)
-
-type L2ModifyOrderTxInfo struct {
-	AccountIndex int64
-	ApiKeyIndex  uint8
-
-	MarketIndex  uint8
-	Index        int64 // Client Order Index or Order Index of the order to modify
-	BaseAmount   int64
-	Price        uint32
-	TriggerPrice uint32
-
-	ExpiredAt  int64
-	Nonce      int64
-	Sig        []byte
-	SignedHash string `json:"-"`
-}
-
-func (txInfo *L2ModifyOrderTxInfo) GetTxType() uint8 {
-	return TxTypeL2ModifyOrder
-}
-
-func (txInfo *L2ModifyOrderTxInfo) GetTxInfo() (string, error) {
-	return getTxInfo(txInfo)
-}
-
-func (txInfo *L2ModifyOrderTxInfo) GetTxHash() string {
-	return txInfo.SignedHash
-}
-
-func (txInfo *L2ModifyOrderTxInfo) Validate() error {
-	// AccountIndex
-	if txInfo.AccountIndex < MinAccountIndex {
-		return ErrAccountIndexTooLow
-	}
-	if txInfo.AccountIndex > MaxAccountIndex {
-		return ErrAccountIndexTooHigh
-	}
-	// ApiKeyIndex
-	if txInfo.ApiKeyIndex < MinApiKeyIndex {
-		return ErrApiKeyIndexTooLow
-	}
-	if txInfo.ApiKeyIndex > MaxApiKeyIndex {
-		return ErrApiKeyIndexTooHigh
-	}
-
-	// MarketIndex
-	if txInfo.MarketIndex < MinMarketIndex {
-		return ErrMarketIndexTooLow
-	}
-	if txInfo.MarketIndex > MaxMarketIndex {
-		return ErrMarketIndexTooHigh
-	}
-
-	// Index
-	if txInfo.Index < MinClientOrderIndex && txInfo.Index < MinOrderIndex {
-		return ErrClientOrderIndexTooLow
-	}
-	if txInfo.Index > MaxClientOrderIndex && txInfo.Index > MaxOrderIndex {
-		return ErrClientOrderIndexTooHigh
-	}
-
-	// BaseAmount
-	if txInfo.BaseAmount != NilOrderBaseAmount && txInfo.BaseAmount < MinOrderBaseAmount {
-		return ErrBaseAmountTooLow
-	}
-	if txInfo.BaseAmount > MaxOrderBaseAmount {
-		return ErrBaseAmountTooHigh
-	}
-
-	// Price
-	if txInfo.Price < MinOrderPrice {
-		return ErrPriceTooLow
-	}
-	if txInfo.Price > MaxOrderPrice {
-		return ErrPriceTooHigh
-	}
-
-	// TriggerPrice
-	if (txInfo.TriggerPrice < MinOrderTriggerPrice || txInfo.TriggerPrice > MaxOrderTriggerPrice) && txInfo.TriggerPrice != NilOrderTriggerPrice {
-		return ErrOrderTriggerPriceInvalid
-	}
-
-	// Nonce
-	if txInfo.Nonce < MinNonce {
-		return ErrNonceTooLow
-	}
-
-	if txInfo.ExpiredAt < 0 || txInfo.ExpiredAt > MaxTimestamp {
-		return ErrExpiredAtInvalid
-	}
-
-	return nil
-}
-
-func (txInfo *L2ModifyOrderTxInfo) Hash(lighterChainId uint32, extra ...g.Element) (msgHash []byte, err error) {
-	elems := make([]g.Element, 0, 11)
-
-	elems = append(elems, g.FromUint32(lighterChainId))
-	elems = append(elems, g.FromUint32(TxTypeL2ModifyOrder))
-	elems = append(elems, g.FromInt64(txInfo.Nonce))
-	elems = append(elems, g.FromInt64(txInfo.ExpiredAt))
-
-	elems = append(elems, g.FromInt64(txInfo.AccountIndex))
-	elems = append(elems, g.FromUint32(uint32(txInfo.ApiKeyIndex)))
-	elems = append(elems, g.FromUint32(uint32(txInfo.MarketIndex)))
-	elems = append(elems, g.FromInt64(txInfo.Index))
-	elems = append(elems, g.FromInt64(txInfo.BaseAmount))
-	elems = append(elems, g.FromUint32(txInfo.Price))
-	elems = append(elems, g.FromUint32(txInfo.TriggerPrice))
-
-	return p2.HashToQuinticExtension(elems).ToLittleEndianBytes(), nil
-}
@@ -1,128 +0,0 @@
-package txtypes
-
-import (
-	"encoding/hex"
-	"fmt"
-	"strings"
-
-	g "github.com/elliottech/poseidon_crypto/field/goldilocks"
-	p2 "github.com/elliottech/poseidon_crypto/hash/poseidon2_goldilocks"
-)
-
-const templateTransfer = "Transfer\n\nnonce: %s\nfrom: %s\napi key: %s\nto: %s\namount: %s\nfee: %s\nmemo: %s\nOnly sign this message for a trusted client!"
-
-var _ TxInfo = (*L2TransferTxInfo)(nil)
-
-type L2TransferTxInfo struct {
-	FromAccountIndex int64
-	ApiKeyIndex      uint8
-
-	ToAccountIndex int64
-	USDCAmount     int64 // USDCAmount is given with 6 decimals
-	Fee            int64
-	Memo           [32]byte
-
-	ExpiredAt  int64
-	Nonce      int64
-	Sig        []byte
-	SignedHash string `json:"-"`
-}
-
-func (txInfo *L2TransferTxInfo) Validate() error {
-	// plus one for treasury account
-	if txInfo.FromAccountIndex < MinAccountIndex+1 {
-		return ErrFromAccountIndexTooLow
-	}
-	if txInfo.FromAccountIndex > MaxAccountIndex {
-		return ErrFromAccountIndexTooHigh
-	}
-
-	// ApiKeyIndex
-	if txInfo.ApiKeyIndex < MinApiKeyIndex {
-		return ErrApiKeyIndexTooLow
-	}
-
-	if txInfo.ApiKeyIndex > MaxApiKeyIndex {
-		return ErrApiKeyIndexTooHigh
-	}
-
-	if txInfo.ToAccountIndex < MinAccountIndex+1 {
-		return ErrToAccountIndexTooLow
-	}
-	if txInfo.ToAccountIndex > MaxAccountIndex {
-		return ErrToAccountIndexTooHigh
-	}
-
-	if txInfo.USDCAmount <= 0 {
-		return ErrTransferAmountTooLow
-	}
-	if txInfo.USDCAmount > MaxTransferAmount {
-		return ErrTransferAmountTooHigh
-	}
-
-	if txInfo.Fee < 0 {
-		return ErrTransferFeeNegative
-	}
-	if txInfo.Fee > MaxTransferAmount {
-		return ErrTransferFeeTooHigh
-	}
-
-	if txInfo.Nonce < MinNonce {
-		return ErrNonceTooLow
-	}
-
-	if txInfo.ExpiredAt < 0 || txInfo.ExpiredAt > MaxTimestamp {
-		return ErrExpiredAtInvalid
-	}
-
-	return nil
-}
-
-func (txInfo *L2TransferTxInfo) GetTxType() uint8 {
-	return TxTypeL2Transfer
-}
-
-func (txInfo *L2TransferTxInfo) GetTxHash() string {
-	return txInfo.SignedHash
-}
-
-func (txInfo *L2TransferTxInfo) GetTxInfo() (string, error) {
-	return getTxInfo(txInfo)
-}
-
-func (txInfo *L2TransferTxInfo) Hash(lighterChainId uint32, extra ...g.Element) (msgHash []byte, err error) {
-	elems := make([]g.Element, 0, 11)
-
-	elems = append(elems, g.FromUint32(lighterChainId))
-	elems = append(elems, g.FromUint32(TxTypeL2Transfer))
-	elems = append(elems, g.FromInt64(txInfo.Nonce))
-	elems = append(elems, g.FromInt64(txInfo.ExpiredAt))
-
-	elems = append(elems, g.FromInt64(txInfo.FromAccountIndex))
-	elems = append(elems, g.FromUint32(uint32(txInfo.ApiKeyIndex)))
-	elems = append(elems, g.FromInt64(txInfo.ToAccountIndex))
-	elems = append(elems, g.FromUint64(uint64(txInfo.USDCAmount)&0xFFFFFFFF)) //nolint:gosec
-	elems = append(elems, g.FromUint64(uint64(txInfo.USDCAmount)>>32))        //nolint:gosec
-	elems = append(elems, g.FromUint64(uint64(txInfo.Fee)&0xFFFFFFFF))        //nolint:gosec
-	elems = append(elems, g.FromUint64(uint64(txInfo.Fee)>>32))               //nolint:gosec
-
-	return p2.HashToQuinticExtension(elems).ToLittleEndianBytes(), nil
-}
-
-func (txInfo *L2TransferTxInfo) GetL1SignatureBody() string {
-	hexMemo := hex.EncodeToString(txInfo.Memo[:])
-	hexMemo = strings.Replace(hexMemo, "0x", "", 1)
-
-	signatureBody := fmt.Sprintf(
-		templateTransfer,
-
-		getHex10FromUint64(uint64(txInfo.Nonce)),
-		getHex10FromUint64(uint64(txInfo.FromAccountIndex)),
-		getHex10FromUint64(uint64(txInfo.ApiKeyIndex)),
-		getHex10FromUint64(uint64(txInfo.ToAccountIndex)),
-		getHex10FromUint64(uint64(txInfo.USDCAmount)),
-		getHex10FromUint64(uint64(txInfo.Fee)),
-		hexMemo,
-	)
-	return signatureBody
-}
@@ -1,98 +0,0 @@
-package txtypes
-
-import (
-	g "github.com/elliottech/poseidon_crypto/field/goldilocks"
-	p2 "github.com/elliottech/poseidon_crypto/hash/poseidon2_goldilocks"
-)
-
-var _ TxInfo = (*L2UpdateLeverageTxInfo)(nil)
-
-type L2UpdateLeverageTxInfo struct {
-	AccountIndex int64
-	ApiKeyIndex  uint8
-
-	MarketIndex           uint8
-	InitialMarginFraction uint16
-	MarginMode            uint8
-
-	ExpiredAt  int64
-	Nonce      int64
-	Sig        []byte
-	SignedHash string `json:"-"`
-}
-
-func (txInfo *L2UpdateLeverageTxInfo) GetTxType() uint8 {
-	return TxTypeL2UpdateLeverage
-}
-
-func (txInfo *L2UpdateLeverageTxInfo) GetTxInfo() (string, error) {
-	return getTxInfo(txInfo)
-}
-
-func (txInfo *L2UpdateLeverageTxInfo) GetTxHash() string {
-	return txInfo.SignedHash
-}
-
-func (txInfo *L2UpdateLeverageTxInfo) Validate() error {
-	if txInfo.AccountIndex < MinAccountIndex {
-		return ErrFromAccountIndexTooLow
-	}
-	if txInfo.AccountIndex > MaxAccountIndex {
-		return ErrFromAccountIndexTooHigh
-	}
-
-	// ApiKeyIndex
-	if txInfo.ApiKeyIndex < MinApiKeyIndex {
-		return ErrApiKeyIndexTooLow
-	}
-	if txInfo.ApiKeyIndex > MaxApiKeyIndex {
-		return ErrApiKeyIndexTooHigh
-	}
-
-	// MarketIndex
-	if txInfo.MarketIndex < MinMarketIndex {
-		return ErrMarketIndexTooLow
-	}
-	if txInfo.MarketIndex > MaxMarketIndex {
-		return ErrMarketIndexTooHigh
-	}
-
-	// InitialMarginFraction
-	if txInfo.InitialMarginFraction <= 0 {
-		return ErrInitialMarginFractionTooLow
-	}
-	if txInfo.InitialMarginFraction > uint16(MarginFractionTick) { //nolint:gosec
-		return ErrInitialMarginFractionTooHigh
-	}
-
-	if txInfo.Nonce < MinNonce {
-		return ErrNonceTooLow
-	}
-
-	if txInfo.ExpiredAt < 0 || txInfo.ExpiredAt > MaxTimestamp {
-		return ErrExpiredAtInvalid
-	}
-
-	if txInfo.MarginMode != CrossMargin && txInfo.MarginMode != IsolatedMargin {
-		return ErrInvalidMarginMode
-	}
-
-	return nil
-}
-
-func (txInfo *L2UpdateLeverageTxInfo) Hash(lighterChainId uint32, extra ...g.Element) (msgHash []byte, err error) {
-	elems := make([]g.Element, 0, 9)
-
-	elems = append(elems, g.FromUint32(lighterChainId))
-	elems = append(elems, g.FromUint32(TxTypeL2UpdateLeverage))
-	elems = append(elems, g.FromInt64(txInfo.Nonce))
-	elems = append(elems, g.FromInt64(txInfo.ExpiredAt))
-
-	elems = append(elems, g.FromInt64(txInfo.AccountIndex))
-	elems = append(elems, g.FromUint32(uint32(txInfo.ApiKeyIndex)))
-	elems = append(elems, g.FromInt64(int64(txInfo.MarketIndex)))
-	elems = append(elems, g.FromInt64(int64(txInfo.InitialMarginFraction)))
-	elems = append(elems, g.FromUint32(uint32(txInfo.MarginMode)))
-
-	return p2.HashToQuinticExtension(elems).ToLittleEndianBytes(), nil
-}
@@ -1,98 +0,0 @@
-package txtypes
-
-import (
-	g "github.com/elliottech/poseidon_crypto/field/goldilocks"
-	p2 "github.com/elliottech/poseidon_crypto/hash/poseidon2_goldilocks"
-)
-
-var _ TxInfo = (*L2UpdateMarginTxInfo)(nil)
-
-type L2UpdateMarginTxInfo struct {
-	AccountIndex int64
-	ApiKeyIndex  uint8
-
-	MarketIndex uint8
-	USDCAmount  int64
-	Direction   uint8
-
-	ExpiredAt  int64
-	Nonce      int64
-	Sig        []byte
-	SignedHash string `json:"-"`
-}
-
-func (txInfo *L2UpdateMarginTxInfo) GetTxType() uint8 {
-	return TxTypeL2UpdateMargin
-}
-
-func (txInfo *L2UpdateMarginTxInfo) GetTxInfo() (string, error) {
-	return getTxInfo(txInfo)
-}
-
-func (txInfo *L2UpdateMarginTxInfo) GetTxHash() string {
-	return txInfo.SignedHash
-}
-
-func (txInfo *L2UpdateMarginTxInfo) Validate() error {
-	if txInfo.AccountIndex < MinAccountIndex {
-		return ErrFromAccountIndexTooLow
-	}
-	if txInfo.AccountIndex > MaxAccountIndex {
-		return ErrFromAccountIndexTooHigh
-	}
-
-	// ApiKeyIndex
-	if txInfo.ApiKeyIndex < MinApiKeyIndex {
-		return ErrApiKeyIndexTooLow
-	}
-	if txInfo.ApiKeyIndex > MaxApiKeyIndex {
-		return ErrApiKeyIndexTooHigh
-	}
-
-	// MarketIndex
-	if txInfo.MarketIndex < MinMarketIndex {
-		return ErrMarketIndexTooLow
-	}
-	if txInfo.MarketIndex > MaxMarketIndex {
-		return ErrMarketIndexTooHigh
-	}
-
-	if txInfo.USDCAmount <= 0 {
-		return ErrTransferAmountTooLow
-	}
-	if txInfo.USDCAmount > MaxTransferAmount {
-		return ErrTransferAmountTooHigh
-	}
-
-	if txInfo.Direction != RemoveFromIsolatedMargin && txInfo.Direction != AddToIsolatedMargin {
-		return ErrInvalidUpdateMarginDirection
-	}
-
-	if txInfo.Nonce < MinNonce {
-		return ErrNonceTooLow
-	}
-
-	if txInfo.ExpiredAt < 0 || txInfo.ExpiredAt > MaxTimestamp {
-		return ErrExpiredAtInvalid
-	}
-
-	return nil
-}
-
-func (txInfo *L2UpdateMarginTxInfo) Hash(lighterChainId uint32, extra ...g.Element) (msgHash []byte, err error) {
-	elems := make([]g.Element, 0, 10)
-
-	elems = append(elems, g.FromUint32(lighterChainId))
-	elems = append(elems, g.FromUint32(TxTypeL2UpdateMargin))
-	elems = append(elems, g.FromInt64(txInfo.Nonce))
-	elems = append(elems, g.FromInt64(txInfo.ExpiredAt))
-
-	elems = append(elems, g.FromInt64(txInfo.AccountIndex))
-	elems = append(elems, g.FromUint32(uint32(txInfo.ApiKeyIndex)))
-	elems = append(elems, g.FromInt64(int64(txInfo.MarketIndex)))
-	elems = append(elems, g.FromUint64(uint64(txInfo.USDCAmount)&0xFFFFFFFF)) //nolint:gosec
-	elems = append(elems, g.FromUint64(uint64(txInfo.USDCAmount)>>32))        //nolint:gosec
-	elems = append(elems, g.FromUint32(uint32(txInfo.Direction)))
-
-	return p2.HashToQuinticExtension(elems).ToLittleEndianBytes(), nil
-}
@@ -1,109 +0,0 @@
-package txtypes
-
-import (
-	g "github.com/elliottech/poseidon_crypto/field/goldilocks"
-	p2 "github.com/elliottech/poseidon_crypto/hash/poseidon2_goldilocks"
-)
-
-var _ TxInfo = (*L2UpdatePublicPoolTxInfo)(nil)
-
-type L2UpdatePublicPoolTxInfo struct {
-	AccountIndex int64 // Master account index
-	ApiKeyIndex  uint8
-
-	PublicPoolIndex int64
-
-	Status               uint8
-	OperatorFee          int64
-	MinOperatorShareRate int64
-
-	ExpiredAt  int64
-	Nonce      int64
-	Sig        []byte
-	SignedHash string `json:"-"`
-}
-
-func (txInfo *L2UpdatePublicPoolTxInfo) GetTxType() uint8 {
-	return TxTypeL2UpdatePublicPool
-}
-
-func (txInfo *L2UpdatePublicPoolTxInfo) GetTxInfo() (string, error) {
-	return getTxInfo(txInfo)
-}
-
-func (txInfo *L2UpdatePublicPoolTxInfo) GetTxHash() string {
-	return txInfo.SignedHash
-}
-
-func (txInfo *L2UpdatePublicPoolTxInfo) Validate() error {
-	// AccountIndex
-	if txInfo.AccountIndex < MinAccountIndex {
-		return ErrFromAccountIndexTooLow
-	}
-	if txInfo.AccountIndex > MaxAccountIndex {
-		return ErrFromAccountIndexTooHigh
-	}
-
-	// ApiKeyIndex
-	if txInfo.ApiKeyIndex < MinApiKeyIndex {
-		return ErrApiKeyIndexTooLow
-	}
-	if txInfo.ApiKeyIndex > MaxApiKeyIndex {
-		return ErrApiKeyIndexTooHigh
-	}
-
-	// PublicPoolIndex
-	if txInfo.PublicPoolIndex < MinAccountIndex {
-		return ErrPublicPoolIndexTooLow
-	}
-	if txInfo.PublicPoolIndex > MaxAccountIndex {
-		return ErrPublicPoolIndexTooHigh
-	}
-
-	// Status
-	if txInfo.Status != 0 && txInfo.Status != 1 {
-		return ErrInvalidPoolStatus
-	}
-
-	// OperatorFee
-	if txInfo.OperatorFee < 0 || txInfo.OperatorFee > FeeTick {
-		return ErrInvalidPoolOperatorFee
-	}
-
-	// MinOperatorShareRate
-	if txInfo.MinOperatorShareRate < 0 {
-		return ErrPoolMinOperatorShareRateTooLow
-	}
-	if txInfo.MinOperatorShareRate > ShareTick {
-		return ErrPoolMinOperatorShareRateTooHigh
-	}
-
-	// Nonce
-	if txInfo.Nonce < MinNonce {
-		return ErrNonceTooLow
-	}
-
-	if txInfo.ExpiredAt < 0 || txInfo.ExpiredAt > MaxTimestamp {
-		return ErrExpiredAtInvalid
-	}
-
-	return nil
-}
-
-func (txInfo *L2UpdatePublicPoolTxInfo) Hash(lighterChainId uint32, extra ...g.Element) (msgHash []byte, err error) {
-	elems := make([]g.Element, 0, 10)
-
-	elems = append(elems, g.FromUint32(lighterChainId))
-	elems = append(elems, g.FromUint32(TxTypeL2UpdatePublicPool))
-	elems = append(elems, g.FromInt64(txInfo.Nonce))
-	elems = append(elems, g.FromInt64(txInfo.ExpiredAt))
-
-	elems = append(elems, g.FromInt64(txInfo.AccountIndex))
-	elems = append(elems, g.FromUint32(uint32(txInfo.ApiKeyIndex)))
-	elems = append(elems, g.FromInt64(txInfo.PublicPoolIndex))
-	elems = append(elems, g.FromUint32(uint32(txInfo.Status)))
-	elems = append(elems, g.FromInt64(txInfo.OperatorFee))
-	elems = append(elems, g.FromInt64(txInfo.MinOperatorShareRate))
-
-	return p2.HashToQuinticExtension(elems).ToLittleEndianBytes(), nil
-}
@@ -1,28 +0,0 @@
-package txtypes
-
-import "encoding/json"
-
-func IsValidPubKey(bytes []byte) bool {
-	if len(bytes) != 40 {
-		return false
-	}
-
-	return !isZeroByteSlice(bytes)
-}
-
-func isZeroByteSlice(bytes []byte) bool {
-	for _, s := range bytes {
-		if s != 0 {
-			return false
-		}
-	}
-	return true
-}
-
-func getTxInfo(tx interface{}) (string, error) {
-	txInfoBytes, err := json.Marshal(tx)
-	if err != nil {
-		return "", err
-	}
-	return string(txInfoBytes), nil
-}
@@ -1,82 +0,0 @@
-package txtypes
-
-import (
-	g "github.com/elliottech/poseidon_crypto/field/goldilocks"
-	p2 "github.com/elliottech/poseidon_crypto/hash/poseidon2_goldilocks"
-)
-
-var _ TxInfo = (*L2WithdrawTxInfo)(nil)
-
-type L2WithdrawTxInfo struct {
-	FromAccountIndex int64
-	ApiKeyIndex      uint8
-
-	USDCAmount uint64 // USDCAmount is given with 6 decimals
-
-	ExpiredAt  int64
-	Nonce      int64
-	Sig        []byte
-	SignedHash string `json:"-"`
-}
-
-func (txInfo *L2WithdrawTxInfo) Validate() error {
-	if txInfo.FromAccountIndex < MinAccountIndex {
-		return ErrFromAccountIndexTooLow
-	}
-	if txInfo.FromAccountIndex > MaxAccountIndex {
-		return ErrFromAccountIndexTooHigh
-	}
-
-	// ApiKeyIndex
-	if txInfo.ApiKeyIndex < MinApiKeyIndex {
-		return ErrApiKeyIndexTooLow
-	}
-	if txInfo.ApiKeyIndex > MaxApiKeyIndex {
-		return ErrApiKeyIndexTooHigh
-	}
-
-	if txInfo.USDCAmount == 0 {
-		return ErrWithdrawalAmountTooLow
-	}
-	if txInfo.USDCAmount > MaxWithdrawalAmount {
-		return ErrWithdrawalAmountTooHigh
-	}
-
-	if txInfo.Nonce < MinNonce {
-		return ErrNonceTooLow
-	}
-
-	if txInfo.ExpiredAt < 0 || txInfo.ExpiredAt > MaxTimestamp {
-		return ErrExpiredAtInvalid
-	}
-
-	return nil
-}
-
-func (txInfo *L2WithdrawTxInfo) GetTxType() uint8 {
-	return TxTypeL2Withdraw
-}
-
-func (txInfo *L2WithdrawTxInfo) GetTxInfo() (string, error) {
-	return getTxInfo(txInfo)
-}
-
-func (txInfo *L2WithdrawTxInfo) GetTxHash() string {
-	return txInfo.SignedHash
-}
-
-func (txInfo *L2WithdrawTxInfo) Hash(lighterChainId uint32, extra ...g.Element) (msgHash []byte, err error) {
-	elems := make([]g.Element, 0, 8)
-
-	elems = append(elems, g.FromUint32(lighterChainId))
-	elems = append(elems, g.FromUint32(TxTypeL2Withdraw))
-	elems = append(elems, g.FromInt64(txInfo.Nonce))
-	elems = append(elems, g.FromInt64(txInfo.ExpiredAt))
-
-	elems = append(elems, g.FromInt64(txInfo.FromAccountIndex))
-	elems = append(elems, g.FromUint32(uint32(txInfo.ApiKeyIndex)))
-	elems = append(elems, g.FromUint64(uint64(txInfo.USDCAmount)&0xFFFFFFFF)) //nolint:gosec
-	elems = append(elems, g.FromUint64(uint64(txInfo.USDCAmount)>>32))        //nolint:gosec
-
-	return p2.HashToQuinticExtension(elems).ToLittleEndianBytes(), nil
-}
@@ -69,3 +69,8 @@ openapi-generator-cli.jar
 .idea

 examples/secrets.py
+
+# Environment variables
+.env
+.env.*
+api_key_config.json
@@ -1,6 +1,7 @@
 docs/Account.md
 docs/AccountApi.md
 docs/AccountApiKeys.md
+docs/AccountAsset.md
 docs/AccountLimits.md
 docs/AccountMarginStats.md
 docs/AccountMarketStats.md
@@ -14,9 +15,12 @@ docs/Announcement.md
 docs/AnnouncementApi.md
 docs/Announcements.md
 docs/ApiKey.md
+docs/Asset.md
+docs/AssetDetails.md
 docs/Block.md
 docs/BlockApi.md
 docs/Blocks.md
+docs/Bridge.md
 docs/BridgeApi.md
 docs/BridgeSupportedNetwork.md
 docs/Candlestick.md
@@ -46,28 +50,27 @@ docs/LiqTrade.md
 docs/Liquidation.md
 docs/LiquidationInfo.md
 docs/LiquidationInfos.md
-docs/MarketInfo.md
+docs/MarketConfig.md
 docs/NextNonce.md
 docs/NotificationApi.md
 docs/Order.md
 docs/OrderApi.md
 docs/OrderBook.md
 docs/OrderBookDepth.md
-docs/OrderBookDetail.md
 docs/OrderBookDetails.md
 docs/OrderBookOrders.md
 docs/OrderBookStats.md
 docs/OrderBooks.md
 docs/Orders.md
+docs/PerpsMarketStats.md
+docs/PerpsOrderBookDetail.md
 docs/PnLEntry.md
 docs/PositionFunding.md
 docs/PositionFundings.md
 docs/PriceLevel.md
-docs/PublicPool.md
 docs/PublicPoolInfo.md
 docs/PublicPoolMetadata.md
 docs/PublicPoolShare.md
-docs/PublicPools.md
 docs/ReferralApi.md
 docs/ReferralPointEntry.md
 docs/ReferralPoints.md
@@ -81,8 +84,10 @@ docs/ReqGetAccountLimits.md
 docs/ReqGetAccountMetadata.md
 docs/ReqGetAccountPnL.md
 docs/ReqGetAccountTxs.md
+docs/ReqGetAssetDetails.md
 docs/ReqGetBlock.md
 docs/ReqGetBlockTxs.md
+docs/ReqGetBridgesByL1Addr.md
 docs/ReqGetByAccount.md
 docs/ReqGetCandlesticks.md
 docs/ReqGetDepositHistory.md
@@ -97,7 +102,6 @@ docs/ReqGetOrderBookDetails.md
 docs/ReqGetOrderBookOrders.md
 docs/ReqGetOrderBooks.md
 docs/ReqGetPositionFunding.md
-docs/ReqGetPublicPools.md
 docs/ReqGetPublicPoolsMetadata.md
 docs/ReqGetRangeWithCursor.md
 docs/ReqGetRangeWithIndex.md
@@ -110,10 +114,14 @@ docs/ReqGetTransferHistory.md
 docs/ReqGetTx.md
 docs/ReqGetWithdrawHistory.md
 docs/RespChangeAccountTier.md
+docs/RespGetBridgesByL1Addr.md
 docs/RespGetFastBridgeInfo.md
+docs/RespGetIsNextBridgeFast.md
 docs/RespPublicPoolsMetadata.md
 docs/RespSendTx.md
 docs/RespSendTxBatch.md
+docs/RespUpdateKickback.md
+docs/RespUpdateReferralCode.md
 docs/RespWithdrawalDelay.md
 docs/ResultCode.md
 docs/RiskInfo.md
@@ -121,6 +129,8 @@ docs/RiskParameters.md
 docs/RootApi.md
 docs/SharePrice.md
 docs/SimpleOrder.md
+docs/SpotMarketStats.md
+docs/SpotOrderBookDetail.md
 docs/Status.md
 docs/SubAccounts.md
 docs/Ticker.md
@@ -160,6 +170,7 @@ lighter/exceptions.py
 lighter/models/__init__.py
 lighter/models/account.py
 lighter/models/account_api_keys.py
+lighter/models/account_asset.py
 lighter/models/account_limits.py
 lighter/models/account_margin_stats.py
 lighter/models/account_market_stats.py
@@ -172,8 +183,11 @@ lighter/models/account_trade_stats.py
 lighter/models/announcement.py
 lighter/models/announcements.py
 lighter/models/api_key.py
+lighter/models/asset.py
+lighter/models/asset_details.py
 lighter/models/block.py
 lighter/models/blocks.py
+lighter/models/bridge.py
 lighter/models/bridge_supported_network.py
 lighter/models/candlestick.py
 lighter/models/candlesticks.py
@@ -199,26 +213,25 @@ lighter/models/liq_trade.py
 lighter/models/liquidation.py
 lighter/models/liquidation_info.py
 lighter/models/liquidation_infos.py
-lighter/models/market_info.py
+lighter/models/market_config.py
 lighter/models/next_nonce.py
 lighter/models/order.py
 lighter/models/order_book.py
 lighter/models/order_book_depth.py
-lighter/models/order_book_detail.py
 lighter/models/order_book_details.py
 lighter/models/order_book_orders.py
 lighter/models/order_book_stats.py
 lighter/models/order_books.py
 lighter/models/orders.py
+lighter/models/perps_market_stats.py
+lighter/models/perps_order_book_detail.py
 lighter/models/pn_l_entry.py
 lighter/models/position_funding.py
 lighter/models/position_fundings.py
 lighter/models/price_level.py
-lighter/models/public_pool.py
 lighter/models/public_pool_info.py
 lighter/models/public_pool_metadata.py
 lighter/models/public_pool_share.py
-lighter/models/public_pools.py
 lighter/models/referral_point_entry.py
 lighter/models/referral_points.py
 lighter/models/req_export_data.py
@@ -231,8 +244,10 @@ lighter/models/req_get_account_limits.py
 lighter/models/req_get_account_metadata.py
 lighter/models/req_get_account_pn_l.py
 lighter/models/req_get_account_txs.py
+lighter/models/req_get_asset_details.py
 lighter/models/req_get_block.py
 lighter/models/req_get_block_txs.py
+lighter/models/req_get_bridges_by_l1_addr.py
 lighter/models/req_get_by_account.py
 lighter/models/req_get_candlesticks.py
 lighter/models/req_get_deposit_history.py
@@ -247,7 +262,6 @@ lighter/models/req_get_order_book_details.py
 lighter/models/req_get_order_book_orders.py
 lighter/models/req_get_order_books.py
 lighter/models/req_get_position_funding.py
-lighter/models/req_get_public_pools.py
 lighter/models/req_get_public_pools_metadata.py
 lighter/models/req_get_range_with_cursor.py
 lighter/models/req_get_range_with_index.py
@@ -260,16 +274,22 @@ lighter/models/req_get_transfer_history.py
 lighter/models/req_get_tx.py
 lighter/models/req_get_withdraw_history.py
 lighter/models/resp_change_account_tier.py
+lighter/models/resp_get_bridges_by_l1_addr.py
 lighter/models/resp_get_fast_bridge_info.py
+lighter/models/resp_get_is_next_bridge_fast.py
 lighter/models/resp_public_pools_metadata.py
 lighter/models/resp_send_tx.py
 lighter/models/resp_send_tx_batch.py
+lighter/models/resp_update_kickback.py
+lighter/models/resp_update_referral_code.py
 lighter/models/resp_withdrawal_delay.py
 lighter/models/result_code.py
 lighter/models/risk_info.py
 lighter/models/risk_parameters.py
 lighter/models/share_price.py
 lighter/models/simple_order.py
+lighter/models/spot_market_stats.py
+lighter/models/spot_order_book_detail.py
 lighter/models/status.py
 lighter/models/sub_accounts.py
 lighter/models/ticker.py
@@ -291,4 +311,19 @@ lighter/rest.py
 setup.cfg
 test-requirements.txt
 test/__init__.py
+test/test_account_asset.py
+test/test_asset.py
+test/test_asset_details.py
+test/test_bridge.py
+test/test_market_config.py
+test/test_perps_market_stats.py
+test/test_perps_order_book_detail.py
+test/test_req_get_asset_details.py
+test/test_req_get_bridges_by_l1_addr.py
+test/test_resp_get_bridges_by_l1_addr.py
+test/test_resp_get_is_next_bridge_fast.py
+test/test_resp_update_kickback.py
+test/test_resp_update_referral_code.py
+test/test_spot_market_stats.py
+test/test_spot_order_book_detail.py
 tox.ini
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
@@ -36,9 +36,12 @@ import asyncio

 async def main():
    client = lighter.ApiClient()
+    try:
        account_api = lighter.AccountApi(client)
-    account = await account_api.get_account(by="index", value="1")
+        account = await account_api.account(by="index", value="1")
        print(account)
+    finally:
+        await client.close()  # Make sure connection is cleanly closed

 if __name__ == "__main__":
    asyncio.run(main())
@@ -0,0 +1,4 @@
+disallowAdditionalPropertiesIfNotPresent: false
+library: asyncio
+packageName: lighter-sdk
+projectName: lighter-sdk
@@ -12,7 +12,6 @@ Name | Type | Description | Notes
 **l1_address** | **str** |  | 
 **cancel_all_time** | **int** |  | 
 **total_order_count** | **int** |  | 
-**total_isolated_order_count** | **int** |  | 
 **pending_order_count** | **int** |  | 
 **available_balance** | **str** |  | 
 **status** | **int** |  | 
@@ -14,7 +14,6 @@ Method | HTTP request | Description
 [**liquidations**](AccountApi.md#liquidations) | **GET** /api/v1/liquidations | liquidations
 [**pnl**](AccountApi.md#pnl) | **GET** /api/v1/pnl | pnl
 [**position_funding**](AccountApi.md#position_funding) | **GET** /api/v1/positionFunding | positionFunding
-[**public_pools**](AccountApi.md#public_pools) | **GET** /api/v1/publicPools | publicPools
 [**public_pools_metadata**](AccountApi.md#public_pools_metadata) | **GET** /api/v1/publicPoolsMetadata | publicPoolsMetadata


@@ -770,85 +769,6 @@ No authorization required

 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

-# **public_pools**
-> PublicPools public_pools(index, limit, authorization=authorization, auth=auth, filter=filter, account_index=account_index)
-
-publicPools
-
-Get public pools
-
-### Example
-
-
-```python
-import lighter
-from lighter.models.public_pools import PublicPools
-from lighter.rest import ApiException
-from pprint import pprint
-
-# Defining the host is optional and defaults to https://mainnet.zklighter.elliot.ai
-# See configuration.py for a list of all supported configuration parameters.
-configuration = lighter.Configuration(
-    host = "https://mainnet.zklighter.elliot.ai"
-)
-
-
-# Enter a context with an instance of the API client
-async with lighter.ApiClient(configuration) as api_client:
-    # Create an instance of the API class
-    api_instance = lighter.AccountApi(api_client)
-    index = 56 # int | 
-    limit = 56 # int | 
-    authorization = 'authorization_example' # str |  (optional)
-    auth = 'auth_example' # str |  (optional)
-    filter = 'filter_example' # str |  (optional)
-    account_index = 56 # int |  (optional)
-
-    try:
-        # publicPools
-        api_response = await api_instance.public_pools(index, limit, authorization=authorization, auth=auth, filter=filter, account_index=account_index)
-        print("The response of AccountApi->public_pools:\n")
-        pprint(api_response)
-    except Exception as e:
-        print("Exception when calling AccountApi->public_pools: %s\n" % e)
-```
-
-
-
-### Parameters
-
-
-Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
- **index** | **int**|  | 
- **limit** | **int**|  | 
- **authorization** | **str**|  | [optional] 
- **auth** | **str**|  | [optional] 
- **filter** | **str**|  | [optional] 
- **account_index** | **int**|  | [optional] 
-
-### Return type
-
-[**PublicPools**](PublicPools.md)
-
-### Authorization
-
-No authorization required
-
-### HTTP request headers
-
- - **Content-Type**: Not defined
- - **Accept**: application/json
-
-### HTTP response details
-
-| Status code | Description | Response headers |
-|-------------|-------------|------------------|
-**200** | A successful response. |  -  |
-**400** | Bad request |  -  |
-
-[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
-
 # **public_pools_metadata**
 > RespPublicPoolsMetadata public_pools_metadata(index, limit, authorization=authorization, auth=auth, filter=filter, account_index=account_index)

@@ -0,0 +1,32 @@
+# AccountAsset
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**symbol** | **str** |  | 
+**asset_id** | **int** |  | 
+**balance** | **str** |  | 
+**locked_balance** | **str** |  | 
+
+## Example
+
+```python
+from lighter.models.account_asset import AccountAsset
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of AccountAsset from a JSON string
+account_asset_instance = AccountAsset.from_json(json)
+# print the JSON string representation of the object
+print(AccountAsset.to_json())
+
+# convert the object into a dict
+account_asset_dict = account_asset_instance.to_dict()
+# create an instance of AccountAsset from a dict
+account_asset_from_dict = AccountAsset.from_dict(account_asset_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
@@ -8,7 +8,9 @@ Name | Type | Description | Notes
 **code** | **int** |  | 
 **message** | **str** |  | [optional] 
 **max_llp_percentage** | **int** |  | 
+**max_llp_amount** | **str** |  | 
 **user_tier** | **str** |  | 
+**can_create_public_pool** | **bool** |  | 

 ## Example

@@ -8,6 +8,7 @@ Name | Type | Description | Notes
 **title** | **str** |  | 
 **content** | **str** |  | 
 **created_at** | **int** |  | 
+**expired_at** | **int** |  | 

 ## Example

@@ -0,0 +1,37 @@
+# Asset
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**asset_id** | **int** |  | 
+**symbol** | **str** |  | 
+**l1_decimals** | **int** |  | 
+**decimals** | **int** |  | 
+**min_transfer_amount** | **str** |  | 
+**min_withdrawal_amount** | **str** |  | 
+**margin_mode** | **str** |  | 
+**index_price** | **str** |  | 
+**l1_address** | **str** |  | 
+
+## Example
+
+```python
+from lighter.models.asset import Asset
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of Asset from a JSON string
+asset_instance = Asset.from_json(json)
+# print the JSON string representation of the object
+print(Asset.to_json())
+
+# convert the object into a dict
+asset_dict = asset_instance.to_dict()
+# create an instance of Asset from a dict
+asset_from_dict = Asset.from_dict(asset_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
@@ -1,4 +1,4 @@
-# PublicPools
+# AssetDetails


 ## Properties
@@ -7,25 +7,24 @@ Name | Type | Description | Notes
 ------------ | ------------- | ------------- | -------------
 **code** | **int** |  | 
 **message** | **str** |  | [optional] 
-**total** | **int** |  | 
-**public_pools** | [**List[PublicPool]**](PublicPool.md) |  | 
+**asset_details** | [**List[Asset]**](Asset.md) |  | 

 ## Example

 ```python
-from lighter.models.public_pools import PublicPools
+from lighter.models.asset_details import AssetDetails

 # TODO update the JSON string below
 json = "{}"
-# create an instance of PublicPools from a JSON string
-public_pools_instance = PublicPools.from_json(json)
+# create an instance of AssetDetails from a JSON string
+asset_details_instance = AssetDetails.from_json(json)
 # print the JSON string representation of the object
-print(PublicPools.to_json())
+print(AssetDetails.to_json())

 # convert the object into a dict
-public_pools_dict = public_pools_instance.to_dict()
-# create an instance of PublicPools from a dict
-public_pools_from_dict = PublicPools.from_dict(public_pools_dict)
+asset_details_dict = asset_details_instance.to_dict()
+# create an instance of AssetDetails from a dict
+asset_details_from_dict = AssetDetails.from_dict(asset_details_dict)
 ```
 [[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

@@ -0,0 +1,43 @@
+# Bridge
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**id** | **int** |  | 
+**version** | **int** |  | 
+**source** | **str** |  | 
+**source_chain_id** | **str** |  | 
+**fast_bridge_tx_hash** | **str** |  | 
+**batch_claim_tx_hash** | **str** |  | 
+**cctp_burn_tx_hash** | **str** |  | 
+**amount** | **str** |  | 
+**intent_address** | **str** |  | 
+**status** | **str** |  | 
+**step** | **str** |  | 
+**description** | **str** |  | 
+**created_at** | **int** |  | 
+**updated_at** | **int** |  | 
+**is_external_deposit** | **bool** |  | 
+
+## Example
+
+```python
+from lighter.models.bridge import Bridge
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of Bridge from a JSON string
+bridge_instance = Bridge.from_json(json)
+# print the JSON string representation of the object
+print(Bridge.to_json())
+
+# convert the object into a dict
+bridge_dict = bridge_instance.to_dict()
+# create an instance of Bridge from a dict
+bridge_from_dict = Bridge.from_dict(bridge_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
@@ -4,9 +4,149 @@ All URIs are relative to *https://mainnet.zklighter.elliot.ai*

 Method | HTTP request | Description
 ------------- | ------------- | -------------
+[**bridges**](BridgeApi.md#bridges) | **GET** /api/v1/bridges | bridges
+[**bridges_is_next_bridge_fast**](BridgeApi.md#bridges_is_next_bridge_fast) | **GET** /api/v1/bridges/isNextBridgeFast | bridges_isNextBridgeFast
 [**fastbridge_info**](BridgeApi.md#fastbridge_info) | **GET** /api/v1/fastbridge/info | fastbridge_info


+# **bridges**
+> RespGetBridgesByL1Addr bridges(l1_address)
+
+bridges
+
+Get bridges for given l1 address
+
+### Example
+
+
+```python
+import lighter
+from lighter.models.resp_get_bridges_by_l1_addr import RespGetBridgesByL1Addr
+from lighter.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://mainnet.zklighter.elliot.ai
+# See configuration.py for a list of all supported configuration parameters.
+configuration = lighter.Configuration(
+    host = "https://mainnet.zklighter.elliot.ai"
+)
+
+
+# Enter a context with an instance of the API client
+async with lighter.ApiClient(configuration) as api_client:
+    # Create an instance of the API class
+    api_instance = lighter.BridgeApi(api_client)
+    l1_address = 'l1_address_example' # str | 
+
+    try:
+        # bridges
+        api_response = await api_instance.bridges(l1_address)
+        print("The response of BridgeApi->bridges:\n")
+        pprint(api_response)
+    except Exception as e:
+        print("Exception when calling BridgeApi->bridges: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **l1_address** | **str**|  | 
+
+### Return type
+
+[**RespGetBridgesByL1Addr**](RespGetBridgesByL1Addr.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | A successful response. |  -  |
+**400** | Bad request |  -  |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **bridges_is_next_bridge_fast**
+> RespGetIsNextBridgeFast bridges_is_next_bridge_fast(l1_address)
+
+bridges_isNextBridgeFast
+
+Get if next bridge is fast
+
+### Example
+
+
+```python
+import lighter
+from lighter.models.resp_get_is_next_bridge_fast import RespGetIsNextBridgeFast
+from lighter.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://mainnet.zklighter.elliot.ai
+# See configuration.py for a list of all supported configuration parameters.
+configuration = lighter.Configuration(
+    host = "https://mainnet.zklighter.elliot.ai"
+)
+
+
+# Enter a context with an instance of the API client
+async with lighter.ApiClient(configuration) as api_client:
+    # Create an instance of the API class
+    api_instance = lighter.BridgeApi(api_client)
+    l1_address = 'l1_address_example' # str | 
+
+    try:
+        # bridges_isNextBridgeFast
+        api_response = await api_instance.bridges_is_next_bridge_fast(l1_address)
+        print("The response of BridgeApi->bridges_is_next_bridge_fast:\n")
+        pprint(api_response)
+    except Exception as e:
+        print("Exception when calling BridgeApi->bridges_is_next_bridge_fast: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **l1_address** | **str**|  | 
+
+### Return type
+
+[**RespGetIsNextBridgeFast**](RespGetIsNextBridgeFast.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | A successful response. |  -  |
+**400** | Bad request |  -  |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
 # **fastbridge_info**
 > RespGetFastBridgeInfo fastbridge_info()

@@ -10,6 +10,10 @@ Name | Type | Description | Notes
 **high** | **float** |  | 
 **low** | **float** |  | 
 **close** | **float** |  | 
+**open_raw** | **float** |  | 
+**high_raw** | **float** |  | 
+**low_raw** | **float** |  | 
+**close_raw** | **float** |  | 
 **volume0** | **float** |  | 
 **volume1** | **float** |  | 
 **last_trade_id** | **int** |  | 
@@ -6,6 +6,7 @@
 Name | Type | Description | Notes
 ------------ | ------------- | ------------- | -------------
 **id** | **str** |  | 
+**asset_id** | **int** |  | 
 **amount** | **str** |  | 
 **timestamp** | **int** |  | 
 **status** | **str** |  | 
@@ -12,7 +12,6 @@ Name | Type | Description | Notes
 **l1_address** | **str** |  | 
 **cancel_all_time** | **int** |  | 
 **total_order_count** | **int** |  | 
-**total_isolated_order_count** | **int** |  | 
 **pending_order_count** | **int** |  | 
 **available_balance** | **str** |  | 
 **status** | **int** |  | 
@@ -23,6 +22,7 @@ Name | Type | Description | Notes
 **can_invite** | **bool** |  Remove After FE uses L1 meta endpoint | 
 **referral_points_percentage** | **str** |  Remove After FE uses L1 meta endpoint | 
 **positions** | [**List[AccountPosition]**](AccountPosition.md) |  | 
+**assets** | [**List[AccountAsset]**](AccountAsset.md) |  | 
 **total_asset_value** | **str** |  | 
 **cross_asset_value** | **str** |  | 
 **pool_info** | [**PublicPoolInfo**](PublicPoolInfo.md) |  | 
@@ -10,6 +10,10 @@ Name | Type | Description | Notes
 **high** | **float** |  | 
 **low** | **float** |  | 
 **close** | **float** |  | 
+**open_raw** | **float** |  | 
+**high_raw** | **float** |  | 
+**low_raw** | **float** |  | 
+**close_raw** | **float** |  | 
 **volume0** | **float** |  | 
 **volume1** | **float** |  | 
 **last_trade_id** | **int** |  | 
@@ -22,6 +22,7 @@ Name | Type | Description | Notes
 **executed_at** | **int** |  | 
 **sequence_index** | **int** |  | 
 **parent_hash** | **str** |  | 
+**api_key_index** | **int** |  | 
 **committed_at** | **int** |  | 
 **verified_at** | **int** |  | 

@@ -0,0 +1,33 @@
+# MarketConfig
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**market_margin_mode** | **int** |  | 
+**insurance_fund_account_index** | **int** |  | 
+**liquidation_mode** | **int** |  | 
+**force_reduce_only** | **bool** |  | 
+**trading_hours** | **str** |  | 
+
+## Example
+
+```python
+from lighter.models.market_config import MarketConfig
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of MarketConfig from a JSON string
+market_config_instance = MarketConfig.from_json(json)
+# print the JSON string representation of the object
+print(MarketConfig.to_json())
+
+# convert the object into a dict
+market_config_dict = market_config_instance.to_dict()
+# create an instance of MarketConfig from a dict
+market_config_from_dict = MarketConfig.from_dict(market_config_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
@@ -36,6 +36,8 @@ Name | Type | Description | Notes
 **to_cancel_order_id_0** | **str** |  | 
 **block_height** | **int** |  | 
 **timestamp** | **int** |  | 
+**created_at** | **int** |  | 
+**updated_at** | **int** |  | 

 ## Example

@@ -6,6 +6,7 @@ Method | HTTP request | Description
 ------------- | ------------- | -------------
 [**account_active_orders**](OrderApi.md#account_active_orders) | **GET** /api/v1/accountActiveOrders | accountActiveOrders
 [**account_inactive_orders**](OrderApi.md#account_inactive_orders) | **GET** /api/v1/accountInactiveOrders | accountInactiveOrders
+[**asset_details**](OrderApi.md#asset_details) | **GET** /api/v1/assetDetails | assetDetails
 [**exchange_stats**](OrderApi.md#exchange_stats) | **GET** /api/v1/exchangeStats | exchangeStats
 [**export**](OrderApi.md#export) | **GET** /api/v1/export | export
 [**order_book_details**](OrderApi.md#order_book_details) | **GET** /api/v1/orderBookDetails | orderBookDetails
@@ -173,6 +174,75 @@ No authorization required

 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

+# **asset_details**
+> AssetDetails asset_details(asset_id=asset_id)
+
+assetDetails
+
+Get asset details
+
+### Example
+
+
+```python
+import lighter
+from lighter.models.asset_details import AssetDetails
+from lighter.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://mainnet.zklighter.elliot.ai
+# See configuration.py for a list of all supported configuration parameters.
+configuration = lighter.Configuration(
+    host = "https://mainnet.zklighter.elliot.ai"
+)
+
+
+# Enter a context with an instance of the API client
+async with lighter.ApiClient(configuration) as api_client:
+    # Create an instance of the API class
+    api_instance = lighter.OrderApi(api_client)
+    asset_id = 0 # int |  (optional) (default to 0)
+
+    try:
+        # assetDetails
+        api_response = await api_instance.asset_details(asset_id=asset_id)
+        print("The response of OrderApi->asset_details:\n")
+        pprint(api_response)
+    except Exception as e:
+        print("Exception when calling OrderApi->asset_details: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **asset_id** | **int**|  | [optional] [default to 0]
+
+### Return type
+
+[**AssetDetails**](AssetDetails.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | A successful response. |  -  |
+**400** | Bad request |  -  |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
 # **exchange_stats**
 > ExchangeStats exchange_stats()

@@ -316,7 +386,7 @@ No authorization required
 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

 # **order_book_details**
-> OrderBookDetails order_book_details(market_id=market_id)
+> OrderBookDetails order_book_details(market_id=market_id, filter=filter)

 orderBookDetails

@@ -343,10 +413,11 @@ async with lighter.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lighter.OrderApi(api_client)
    market_id = 255 # int |  (optional) (default to 255)
+    filter = all # str |  (optional) (default to all)

    try:
        # orderBookDetails
-        api_response = await api_instance.order_book_details(market_id=market_id)
+        api_response = await api_instance.order_book_details(market_id=market_id, filter=filter)
        print("The response of OrderApi->order_book_details:\n")
        pprint(api_response)
    except Exception as e:
@@ -361,6 +432,7 @@ async with lighter.ApiClient(configuration) as api_client:
 Name | Type | Description  | Notes
 ------------- | ------------- | ------------- | -------------
 **market_id** | **int**|  | [optional] [default to 255]
+ **filter** | **str**|  | [optional] [default to all]

 ### Return type

@@ -456,7 +528,7 @@ No authorization required
 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

 # **order_books**
-> OrderBooks order_books(market_id=market_id)
+> OrderBooks order_books(market_id=market_id, filter=filter)

 orderBooks

@@ -483,10 +555,11 @@ async with lighter.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lighter.OrderApi(api_client)
    market_id = 255 # int |  (optional) (default to 255)
+    filter = all # str |  (optional) (default to all)

    try:
        # orderBooks
-        api_response = await api_instance.order_books(market_id=market_id)
+        api_response = await api_instance.order_books(market_id=market_id, filter=filter)
        print("The response of OrderApi->order_books:\n")
        pprint(api_response)
    except Exception as e:
@@ -501,6 +574,7 @@ async with lighter.ApiClient(configuration) as api_client:
 Name | Type | Description  | Notes
 ------------- | ------------- | ------------- | -------------
 **market_id** | **int**|  | [optional] [default to 255]
+ **filter** | **str**|  | [optional] [default to all]

 ### Return type

@@ -596,7 +670,7 @@ No authorization required
 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

 # **trades**
-> Trades trades(sort_by, limit, authorization=authorization, auth=auth, market_id=market_id, account_index=account_index, order_index=order_index, sort_dir=sort_dir, cursor=cursor, var_from=var_from, ask_filter=ask_filter)
+> Trades trades(sort_by, limit, authorization=authorization, auth=auth, market_id=market_id, account_index=account_index, order_index=order_index, sort_dir=sort_dir, cursor=cursor, var_from=var_from, ask_filter=ask_filter, role=role, type=type, aggregate=aggregate)

 trades

@@ -633,10 +707,13 @@ async with lighter.ApiClient(configuration) as api_client:
    cursor = 'cursor_example' # str |  (optional)
    var_from = -1 # int |  (optional) (default to -1)
    ask_filter = -1 # int |  (optional) (default to -1)
+    role = all # str |  (optional) (default to all)
+    type = all # str |  (optional) (default to all)
+    aggregate = False # bool |  (optional) (default to False)

    try:
        # trades
-        api_response = await api_instance.trades(sort_by, limit, authorization=authorization, auth=auth, market_id=market_id, account_index=account_index, order_index=order_index, sort_dir=sort_dir, cursor=cursor, var_from=var_from, ask_filter=ask_filter)
+        api_response = await api_instance.trades(sort_by, limit, authorization=authorization, auth=auth, market_id=market_id, account_index=account_index, order_index=order_index, sort_dir=sort_dir, cursor=cursor, var_from=var_from, ask_filter=ask_filter, role=role, type=type, aggregate=aggregate)
        print("The response of OrderApi->trades:\n")
        pprint(api_response)
    except Exception as e:
@@ -661,6 +738,9 @@ Name | Type | Description  | Notes
 **cursor** | **str**|  | [optional] 
 **var_from** | **int**|  | [optional] [default to -1]
 **ask_filter** | **int**|  | [optional] [default to -1]
+ **role** | **str**|  | [optional] [default to all]
+ **type** | **str**|  | [optional] [default to all]
+ **aggregate** | **bool**|  | [optional] [default to False]

 ### Return type

@@ -7,12 +7,16 @@ Name | Type | Description | Notes
 ------------ | ------------- | ------------- | -------------
 **symbol** | **str** |  | 
 **market_id** | **int** |  | 
+**market_type** | **str** |  | 
+**base_asset_id** | **int** |  | 
+**quote_asset_id** | **int** |  | 
 **status** | **str** |  | 
 **taker_fee** | **str** |  | 
 **maker_fee** | **str** |  | 
 **liquidation_fee** | **str** |  | 
 **min_base_amount** | **str** |  | 
 **min_quote_amount** | **str** |  | 
+**order_quote_limit** | **str** |  | 
 **supported_size_decimals** | **int** |  | 
 **supported_price_decimals** | **int** |  | 
 **supported_quote_decimals** | **int** |  | 
@@ -10,6 +10,7 @@ Name | Type | Description | Notes
 **asks** | [**List[PriceLevel]**](PriceLevel.md) |  | 
 **bids** | [**List[PriceLevel]**](PriceLevel.md) |  | 
 **offset** | **int** |  | 
+**nonce** | **int** |  | 

 ## Example

@@ -7,7 +7,8 @@ Name | Type | Description | Notes
 ------------ | ------------- | ------------- | -------------
 **code** | **int** |  | 
 **message** | **str** |  | [optional] 
-**order_book_details** | [**List[OrderBookDetail]**](OrderBookDetail.md) |  | 
+**order_book_details** | [**List[PerpsOrderBookDetail]**](PerpsOrderBookDetail.md) |  | 
+**spot_order_book_details** | [**List[SpotOrderBookDetail]**](SpotOrderBookDetail.md) |  | 

 ## Example

@@ -1,14 +1,18 @@
-# MarketInfo
+# PerpsMarketStats


 ## Properties

 Name | Type | Description | Notes
 ------------ | ------------- | ------------- | -------------
+**symbol** | **str** |  | 
 **market_id** | **int** |  | 
 **index_price** | **str** |  | 
 **mark_price** | **str** |  | 
 **open_interest** | **str** |  | 
+**open_interest_limit** | **str** |  | 
+**funding_clamp_small** | **str** |  | 
+**funding_clamp_big** | **str** |  | 
 **last_trade_price** | **str** |  | 
 **current_funding_rate** | **str** |  | 
 **funding_rate** | **str** |  | 
@@ -22,19 +26,19 @@ Name | Type | Description | Notes
 ## Example

 ```python
-from lighter.models.market_info import MarketInfo
+from lighter.models.perps_market_stats import PerpsMarketStats

 # TODO update the JSON string below
 json = "{}"
-# create an instance of MarketInfo from a JSON string
-market_info_instance = MarketInfo.from_json(json)
+# create an instance of PerpsMarketStats from a JSON string
+perps_market_stats_instance = PerpsMarketStats.from_json(json)
 # print the JSON string representation of the object
-print(MarketInfo.to_json())
+print(PerpsMarketStats.to_json())

 # convert the object into a dict
-market_info_dict = market_info_instance.to_dict()
-# create an instance of MarketInfo from a dict
-market_info_from_dict = MarketInfo.from_dict(market_info_dict)
+perps_market_stats_dict = perps_market_stats_instance.to_dict()
+# create an instance of PerpsMarketStats from a dict
+perps_market_stats_from_dict = PerpsMarketStats.from_dict(perps_market_stats_dict)
 ```
 [[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

@@ -1,4 +1,4 @@
-# OrderBookDetail
+# PerpsOrderBookDetail


 ## Properties
@@ -7,12 +7,16 @@ Name | Type | Description | Notes
 ------------ | ------------- | ------------- | -------------
 **symbol** | **str** |  | 
 **market_id** | **int** |  | 
+**market_type** | **str** |  | 
+**base_asset_id** | **int** |  | 
+**quote_asset_id** | **int** |  | 
 **status** | **str** |  | 
 **taker_fee** | **str** |  | 
 **maker_fee** | **str** |  | 
 **liquidation_fee** | **str** |  | 
 **min_base_amount** | **str** |  | 
 **min_quote_amount** | **str** |  | 
+**order_quote_limit** | **str** |  | 
 **supported_size_decimals** | **int** |  | 
 **supported_price_decimals** | **int** |  | 
 **supported_quote_decimals** | **int** |  | 
@@ -32,23 +36,24 @@ Name | Type | Description | Notes
 **daily_price_change** | **float** |  | 
 **open_interest** | **float** |  | 
 **daily_chart** | **Dict[str, float]** |  | 
+**market_config** | [**MarketConfig**](MarketConfig.md) |  | 

 ## Example

 ```python
-from lighter.models.order_book_detail import OrderBookDetail
+from lighter.models.perps_order_book_detail import PerpsOrderBookDetail

 # TODO update the JSON string below
 json = "{}"
-# create an instance of OrderBookDetail from a JSON string
-order_book_detail_instance = OrderBookDetail.from_json(json)
+# create an instance of PerpsOrderBookDetail from a JSON string
+perps_order_book_detail_instance = PerpsOrderBookDetail.from_json(json)
 # print the JSON string representation of the object
-print(OrderBookDetail.to_json())
+print(PerpsOrderBookDetail.to_json())

 # convert the object into a dict
-order_book_detail_dict = order_book_detail_instance.to_dict()
-# create an instance of OrderBookDetail from a dict
-order_book_detail_from_dict = OrderBookDetail.from_dict(order_book_detail_dict)
+perps_order_book_detail_dict = perps_order_book_detail_instance.to_dict()
+# create an instance of PerpsOrderBookDetail from a dict
+perps_order_book_detail_from_dict = PerpsOrderBookDetail.from_dict(perps_order_book_detail_dict)
 ```
 [[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

@@ -7,8 +7,11 @@ Name | Type | Description | Notes
 ------------ | ------------- | ------------- | -------------
 **timestamp** | **int** |  | 
 **trade_pnl** | **float** |  | 
+**trade_spot_pnl** | **float** |  | 
 **inflow** | **float** |  | 
 **outflow** | **float** |  | 
+**spot_outflow** | **float** |  | 
+**spot_inflow** | **float** |  | 
 **pool_pnl** | **float** |  | 
 **pool_inflow** | **float** |  | 
 **pool_outflow** | **float** |  | 
@@ -1,49 +0,0 @@
-# PublicPool
-
-
-## Properties
-
-Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
-**code** | **int** |  | 
-**message** | **str** |  | [optional] 
-**account_type** | **int** |  | 
-**index** | **int** |  | 
-**l1_address** | **str** |  | 
-**cancel_all_time** | **int** |  | 
-**total_order_count** | **int** |  | 
-**total_isolated_order_count** | **int** |  | 
-**pending_order_count** | **int** |  | 
-**available_balance** | **str** |  | 
-**status** | **int** |  | 
-**collateral** | **str** |  | 
-**account_index** | **int** |  | 
-**name** | **str** |  | 
-**description** | **str** |  | 
-**can_invite** | **bool** |  Remove After FE uses L1 meta endpoint | 
-**referral_points_percentage** | **str** |  Remove After FE uses L1 meta endpoint | 
-**total_asset_value** | **str** |  | 
-**cross_asset_value** | **str** |  | 
-**pool_info** | [**PublicPoolInfo**](PublicPoolInfo.md) |  | 
-**account_share** | [**PublicPoolShare**](PublicPoolShare.md) |  | [optional] 
-
-## Example
-
-```python
-from lighter.models.public_pool import PublicPool
-
-# TODO update the JSON string below
-json = "{}"
-# create an instance of PublicPool from a JSON string
-public_pool_instance = PublicPool.from_json(json)
-# print the JSON string representation of the object
-print(PublicPool.to_json())
-
-# convert the object into a dict
-public_pool_dict = public_pool_instance.to_dict()
-# create an instance of PublicPool from a dict
-public_pool_from_dict = PublicPool.from_dict(public_pool_dict)
-```
-[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
-
-
@@ -11,6 +11,7 @@ Name | Type | Description | Notes
 **total_shares** | **int** |  | 
 **operator_shares** | **int** |  | 
 **annual_percentage_yield** | **float** |  | 
+**sharpe_ratio** | **float** |  | 
 **daily_returns** | [**List[DailyReturn]**](DailyReturn.md) |  | 
 **share_prices** | [**List[SharePrice]**](SharePrice.md) |  | 

@@ -8,10 +8,13 @@ Name | Type | Description | Notes
 **code** | **int** |  | 
 **message** | **str** |  | [optional] 
 **account_index** | **int** |  | 
+**created_at** | **int** |  | 
+**master_account_index** | **int** |  | 
 **account_type** | **int** |  | 
 **name** | **str** |  | 
 **l1_address** | **str** |  | 
 **annual_percentage_yield** | **float** |  | 
+**sharpe_ratio** | **float** |  | 
 **status** | **int** |  | 
 **operator_fee** | **str** |  | 
 **total_asset_value** | **str** |  | 
@@ -4,9 +4,86 @@ All URIs are relative to *https://mainnet.zklighter.elliot.ai*

 Method | HTTP request | Description
 ------------- | ------------- | -------------
+[**referral_kickback_update**](ReferralApi.md#referral_kickback_update) | **POST** /api/v1/referral/kickback/update | referral_kickback_update
 [**referral_points**](ReferralApi.md#referral_points) | **GET** /api/v1/referral/points | referral_points
+[**referral_update**](ReferralApi.md#referral_update) | **POST** /api/v1/referral/update | referral_update


+# **referral_kickback_update**
+> RespUpdateKickback referral_kickback_update(account_index, kickback_percentage, authorization=authorization, auth=auth)
+
+referral_kickback_update
+
+Update kickback percentage for referral rewards
+
+### Example
+
+
+```python
+import lighter
+from lighter.models.resp_update_kickback import RespUpdateKickback
+from lighter.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://mainnet.zklighter.elliot.ai
+# See configuration.py for a list of all supported configuration parameters.
+configuration = lighter.Configuration(
+    host = "https://mainnet.zklighter.elliot.ai"
+)
+
+
+# Enter a context with an instance of the API client
+async with lighter.ApiClient(configuration) as api_client:
+    # Create an instance of the API class
+    api_instance = lighter.ReferralApi(api_client)
+    account_index = 56 # int | 
+    kickback_percentage = 3.4 # float | 
+    authorization = 'authorization_example' # str |  make required after integ is done (optional)
+    auth = 'auth_example' # str |  made optional to support header auth clients (optional)
+
+    try:
+        # referral_kickback_update
+        api_response = await api_instance.referral_kickback_update(account_index, kickback_percentage, authorization=authorization, auth=auth)
+        print("The response of ReferralApi->referral_kickback_update:\n")
+        pprint(api_response)
+    except Exception as e:
+        print("Exception when calling ReferralApi->referral_kickback_update: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **account_index** | **int**|  | 
+ **kickback_percentage** | **float**|  | 
+ **authorization** | **str**|  make required after integ is done | [optional] 
+ **auth** | **str**|  made optional to support header auth clients | [optional] 
+
+### Return type
+
+[**RespUpdateKickback**](RespUpdateKickback.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: multipart/form-data
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | A successful response. |  -  |
+**400** | Bad request |  -  |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
 # **referral_points**
 > ReferralPoints referral_points(account_index, authorization=authorization, auth=auth)

@@ -80,3 +157,78 @@ No authorization required

 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

+# **referral_update**
+> RespUpdateReferralCode referral_update(account_index, new_referral_code, authorization=authorization, auth=auth)
+
+referral_update
+
+Update referral code (allowed once per account)
+
+### Example
+
+
+```python
+import lighter
+from lighter.models.resp_update_referral_code import RespUpdateReferralCode
+from lighter.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://mainnet.zklighter.elliot.ai
+# See configuration.py for a list of all supported configuration parameters.
+configuration = lighter.Configuration(
+    host = "https://mainnet.zklighter.elliot.ai"
+)
+
+
+# Enter a context with an instance of the API client
+async with lighter.ApiClient(configuration) as api_client:
+    # Create an instance of the API class
+    api_instance = lighter.ReferralApi(api_client)
+    account_index = 56 # int | 
+    new_referral_code = 'new_referral_code_example' # str | 
+    authorization = 'authorization_example' # str |  make required after integ is done (optional)
+    auth = 'auth_example' # str |  made optional to support header auth clients (optional)
+
+    try:
+        # referral_update
+        api_response = await api_instance.referral_update(account_index, new_referral_code, authorization=authorization, auth=auth)
+        print("The response of ReferralApi->referral_update:\n")
+        pprint(api_response)
+    except Exception as e:
+        print("Exception when calling ReferralApi->referral_update: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **account_index** | **int**|  | 
+ **new_referral_code** | **str**|  | 
+ **authorization** | **str**|  make required after integ is done | [optional] 
+ **auth** | **str**|  made optional to support header auth clients | [optional] 
+
+### Return type
+
+[**RespUpdateReferralCode**](RespUpdateReferralCode.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: multipart/form-data
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | A successful response. |  -  |
+**400** | Bad request |  -  |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
@@ -6,10 +6,10 @@
 Name | Type | Description | Notes
 ------------ | ------------- | ------------- | -------------
 **l1_address** | **str** |  | 
-**total_points** | **int** |  | 
-**week_points** | **int** |  | 
-**total_reward_points** | **int** |  | 
-**week_reward_points** | **int** |  | 
+**total_points** | **float** |  | 
+**week_points** | **float** |  | 
+**total_reward_points** | **float** |  | 
+**week_reward_points** | **float** |  | 
 **reward_point_multiplier** | **str** |  | 

 ## Example
@@ -6,10 +6,10 @@
 Name | Type | Description | Notes
 ------------ | ------------- | ------------- | -------------
 **referrals** | [**List[ReferralPointEntry]**](ReferralPointEntry.md) |  | 
-**user_total_points** | **int** |  | 
-**user_last_week_points** | **int** |  | 
-**user_total_referral_reward_points** | **int** |  | 
-**user_last_week_referral_reward_points** | **int** |  | 
+**user_total_points** | **float** |  | 
+**user_last_week_points** | **float** |  | 
+**user_total_referral_reward_points** | **float** |  | 
+**user_last_week_referral_reward_points** | **float** |  | 
 **reward_point_multiplier** | **str** |  | 

 ## Example
@@ -0,0 +1,29 @@
+# ReqGetAssetDetails
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**asset_id** | **int** |  | [optional] 
+
+## Example
+
+```python
+from lighter.models.req_get_asset_details import ReqGetAssetDetails
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ReqGetAssetDetails from a JSON string
+req_get_asset_details_instance = ReqGetAssetDetails.from_json(json)
+# print the JSON string representation of the object
+print(ReqGetAssetDetails.to_json())
+
+# convert the object into a dict
+req_get_asset_details_dict = req_get_asset_details_instance.to_dict()
+# create an instance of ReqGetAssetDetails from a dict
+req_get_asset_details_from_dict = ReqGetAssetDetails.from_dict(req_get_asset_details_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
@@ -0,0 +1,29 @@
+# ReqGetBridgesByL1Addr
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**l1_address** | **str** |  | 
+
+## Example
+
+```python
+from lighter.models.req_get_bridges_by_l1_addr import ReqGetBridgesByL1Addr
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ReqGetBridgesByL1Addr from a JSON string
+req_get_bridges_by_l1_addr_instance = ReqGetBridgesByL1Addr.from_json(json)
+# print the JSON string representation of the object
+print(ReqGetBridgesByL1Addr.to_json())
+
+# convert the object into a dict
+req_get_bridges_by_l1_addr_dict = req_get_bridges_by_l1_addr_instance.to_dict()
+# create an instance of ReqGetBridgesByL1Addr from a dict
+req_get_bridges_by_l1_addr_from_dict = ReqGetBridgesByL1Addr.from_dict(req_get_bridges_by_l1_addr_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
@@ -6,6 +6,7 @@
 Name | Type | Description | Notes
 ------------ | ------------- | ------------- | -------------
 **market_id** | **int** |  | [optional] 
+**filter** | **str** |  | [optional] [default to 'all']

 ## Example

@@ -6,6 +6,7 @@
 Name | Type | Description | Notes
 ------------ | ------------- | ------------- | -------------
 **market_id** | **int** |  | [optional] 
+**filter** | **str** |  | [optional] [default to 'all']

 ## Example

@@ -1,33 +0,0 @@
-# ReqGetPublicPools
-
-
-## Properties
-
-Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
-**auth** | **str** |  | [optional] 
-**filter** | **str** |  | [optional] 
-**index** | **int** |  | 
-**limit** | **int** |  | 
-**account_index** | **int** |  | [optional] 
-
-## Example
-
-```python
-from lighter.models.req_get_public_pools import ReqGetPublicPools
-
-# TODO update the JSON string below
-json = "{}"
-# create an instance of ReqGetPublicPools from a JSON string
-req_get_public_pools_instance = ReqGetPublicPools.from_json(json)
-# print the JSON string representation of the object
-print(ReqGetPublicPools.to_json())
-
-# convert the object into a dict
-req_get_public_pools_dict = req_get_public_pools_instance.to_dict()
-# create an instance of ReqGetPublicPools from a dict
-req_get_public_pools_from_dict = ReqGetPublicPools.from_dict(req_get_public_pools_dict)
-```
-[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
-
-
@@ -14,7 +14,10 @@ Name | Type | Description | Notes
 **cursor** | **str** |  | [optional] 
 **var_from** | **int** |  | [optional] [default to -1]
 **ask_filter** | **int** |  | [optional] 
+**role** | **str** |  | [optional] [default to 'all']
+**type** | **str** |  | [optional] [default to 'all']
 **limit** | **int** |  | 
+**aggregate** | **bool** |  | [optional] [default to False]

 ## Example

@@ -0,0 +1,31 @@
+# RespGetBridgesByL1Addr
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**code** | **int** |  | 
+**message** | **str** |  | [optional] 
+**bridges** | [**List[Bridge]**](Bridge.md) |  | 
+
+## Example
+
+```python
+from lighter.models.resp_get_bridges_by_l1_addr import RespGetBridgesByL1Addr
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of RespGetBridgesByL1Addr from a JSON string
+resp_get_bridges_by_l1_addr_instance = RespGetBridgesByL1Addr.from_json(json)
+# print the JSON string representation of the object
+print(RespGetBridgesByL1Addr.to_json())
+
+# convert the object into a dict
+resp_get_bridges_by_l1_addr_dict = resp_get_bridges_by_l1_addr_instance.to_dict()
+# create an instance of RespGetBridgesByL1Addr from a dict
+resp_get_bridges_by_l1_addr_from_dict = RespGetBridgesByL1Addr.from_dict(resp_get_bridges_by_l1_addr_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
@@ -0,0 +1,31 @@
+# RespGetIsNextBridgeFast
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**code** | **int** |  | 
+**message** | **str** |  | [optional] 
+**is_next_bridge_fast** | **bool** |  | 
+
+## Example
+
+```python
+from lighter.models.resp_get_is_next_bridge_fast import RespGetIsNextBridgeFast
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of RespGetIsNextBridgeFast from a JSON string
+resp_get_is_next_bridge_fast_instance = RespGetIsNextBridgeFast.from_json(json)
+# print the JSON string representation of the object
+print(RespGetIsNextBridgeFast.to_json())
+
+# convert the object into a dict
+resp_get_is_next_bridge_fast_dict = resp_get_is_next_bridge_fast_instance.to_dict()
+# create an instance of RespGetIsNextBridgeFast from a dict
+resp_get_is_next_bridge_fast_from_dict = RespGetIsNextBridgeFast.from_dict(resp_get_is_next_bridge_fast_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
@@ -9,6 +9,7 @@ Name | Type | Description | Notes
 **message** | **str** |  | [optional] 
 **tx_hash** | **str** |  | 
 **predicted_execution_time_ms** | **int** |  | 
+**volume_quota_remaining** | **int** |  | 

 ## Example

@@ -9,6 +9,7 @@ Name | Type | Description | Notes
 **message** | **str** |  | [optional] 
 **tx_hash** | **List[str]** |  | 
 **predicted_execution_time_ms** | **int** |  | 
+**volume_quota_remaining** | **int** |  | 

 ## Example

@@ -0,0 +1,31 @@
+# RespUpdateKickback
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**code** | **int** |  | 
+**message** | **str** |  | [optional] 
+**success** | **bool** |  | 
+
+## Example
+
+```python
+from lighter.models.resp_update_kickback import RespUpdateKickback
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of RespUpdateKickback from a JSON string
+resp_update_kickback_instance = RespUpdateKickback.from_json(json)
+# print the JSON string representation of the object
+print(RespUpdateKickback.to_json())
+
+# convert the object into a dict
+resp_update_kickback_dict = resp_update_kickback_instance.to_dict()
+# create an instance of RespUpdateKickback from a dict
+resp_update_kickback_from_dict = RespUpdateKickback.from_dict(resp_update_kickback_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
@@ -0,0 +1,31 @@
+# RespUpdateReferralCode
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**code** | **int** |  | 
+**message** | **str** |  | [optional] 
+**success** | **bool** |  | 
+
+## Example
+
+```python
+from lighter.models.resp_update_referral_code import RespUpdateReferralCode
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of RespUpdateReferralCode from a JSON string
+resp_update_referral_code_instance = RespUpdateReferralCode.from_json(json)
+# print the JSON string representation of the object
+print(RespUpdateReferralCode.to_json())
+
+# convert the object into a dict
+resp_update_referral_code_dict = resp_update_referral_code_instance.to_dict()
+# create an instance of RespUpdateReferralCode from a dict
+resp_update_referral_code_from_dict = RespUpdateReferralCode.from_dict(resp_update_referral_code_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
@@ -0,0 +1,38 @@
+# SpotMarketStats
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**symbol** | **str** |  | 
+**market_id** | **int** |  | 
+**index_price** | **str** |  | 
+**mid_price** | **str** |  | 
+**last_trade_price** | **str** |  | 
+**daily_base_token_volume** | **float** |  | 
+**daily_quote_token_volume** | **float** |  | 
+**daily_price_low** | **float** |  | 
+**daily_price_high** | **float** |  | 
+**daily_price_change** | **float** |  | 
+
+## Example
+
+```python
+from lighter.models.spot_market_stats import SpotMarketStats
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SpotMarketStats from a JSON string
+spot_market_stats_instance = SpotMarketStats.from_json(json)
+# print the JSON string representation of the object
+print(SpotMarketStats.to_json())
+
+# convert the object into a dict
+spot_market_stats_dict = spot_market_stats_instance.to_dict()
+# create an instance of SpotMarketStats from a dict
+spot_market_stats_from_dict = SpotMarketStats.from_dict(spot_market_stats_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
@@ -0,0 +1,53 @@
+# SpotOrderBookDetail
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**symbol** | **str** |  | 
+**market_id** | **int** |  | 
+**market_type** | **str** |  | 
+**base_asset_id** | **int** |  | 
+**quote_asset_id** | **int** |  | 
+**status** | **str** |  | 
+**taker_fee** | **str** |  | 
+**maker_fee** | **str** |  | 
+**liquidation_fee** | **str** |  | 
+**min_base_amount** | **str** |  | 
+**min_quote_amount** | **str** |  | 
+**order_quote_limit** | **str** |  | 
+**supported_size_decimals** | **int** |  | 
+**supported_price_decimals** | **int** |  | 
+**supported_quote_decimals** | **int** |  | 
+**size_decimals** | **int** |  | 
+**price_decimals** | **int** |  | 
+**last_trade_price** | **float** |  | 
+**daily_trades_count** | **int** |  | 
+**daily_base_token_volume** | **float** |  | 
+**daily_quote_token_volume** | **float** |  | 
+**daily_price_low** | **float** |  | 
+**daily_price_high** | **float** |  | 
+**daily_price_change** | **float** |  | 
+**daily_chart** | **Dict[str, float]** |  | 
+
+## Example
+
+```python
+from lighter.models.spot_order_book_detail import SpotOrderBookDetail
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SpotOrderBookDetail from a JSON string
+spot_order_book_detail_instance = SpotOrderBookDetail.from_json(json)
+# print the JSON string representation of the object
+print(SpotOrderBookDetail.to_json())
+
+# convert the object into a dict
+spot_order_book_detail_dict = spot_order_book_detail_instance.to_dict()
+# create an instance of SpotOrderBookDetail from a dict
+spot_order_book_detail_from_dict = SpotOrderBookDetail.from_dict(spot_order_book_detail_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
@@ -14,6 +14,8 @@ Name | Type | Description | Notes
 **usd_amount** | **str** |  | 
 **ask_id** | **int** |  | 
 **bid_id** | **int** |  | 
+**ask_client_id** | **int** |  | 
+**bid_client_id** | **int** |  | 
 **ask_account_id** | **int** |  | 
 **bid_account_id** | **int** |  | 
 **is_maker_ask** | **bool** |  | 
@@ -6,6 +6,7 @@
 Name | Type | Description | Notes
 ------------ | ------------- | ------------- | -------------
 **id** | **str** |  | 
+**asset_id** | **int** |  | 
 **amount** | **str** |  | 
 **timestamp** | **int** |  | 
 **type** | **str** |  | 
@@ -13,6 +14,8 @@ Name | Type | Description | Notes
 **to_l1_address** | **str** |  | 
 **from_account_index** | **int** |  | 
 **to_account_index** | **int** |  | 
+**from_route** | **str** |  | 
+**to_route** | **str** |  | 
 **tx_hash** | **str** |  | 

 ## Example
@@ -20,6 +20,7 @@ Name | Type | Description | Notes
 **executed_at** | **int** |  | 
 **sequence_index** | **int** |  | 
 **parent_hash** | **str** |  | 
+**api_key_index** | **int** |  | 

 ## Example

@@ -6,6 +6,7 @@
 Name | Type | Description | Notes
 ------------ | ------------- | ------------- | -------------
 **id** | **str** |  | 
+**asset_id** | **int** |  | 
 **amount** | **str** |  | 
 **timestamp** | **int** |  | 
 **status** | **str** |  | 
@@ -0,0 +1 @@
+api_key_config.json
@@ -6,17 +6,151 @@
  - the eth private key will only be used in the Py SDK to sign a message
  - the eth private key is not required in order to trade on the platform
  - the eth private key is not passed to the binary 
-  - copy the output of the script and post it into `create_cancel_order.py`
-  - the output should look like
-```
-BASE_URL = 'https://testnet.zklighter.elliot.ai'
-API_KEY_PRIVATE_KEY = '0xea5d2eca5be67eca056752eaf27b173518b8a5550117c09d2b58c7ea7d306cc4426f913ccf27ab19'
-ACCOUNT_INDEX = 595
-API_KEY_INDEX = 1
-```
- start trading using
-  - `create_cancel_order.py` has an example which created an order on testnet & cancels it
-  - you'll need to set up both your account index, api key index & API Key private key
+  - the API key config is saved in a local file `./api_key_config.json`
+
+## Start trading on testnet
+- `create_modify_cancel_order_http.py`
+  - creates an ask (sell) order for 0.1 ETH @ $4050
+  - modified the order and increases the size to 0.11 ETH and increases the price to $4100
+  - cancels the order
+  - Note: all of these operations use the client order index of the order. You can use the order from the exchange as well
+  
+- `create_modify_cancel_order_ws.py`
+  - same flow as `create_modify_cancel_order_http.py`
+  - sends TXs over WS instead of HTTP
+
+- `create_market_order_eth_buy.py`
+  - creates a market buy order for 0.1 ETH @ market price
+- `create_market_order_eth_sell.py`
+  - creates a market sell order for 0.1 ETH @ market price
+
+- `create_grouped_ioc_with_attached_sl_tp.py`
+  - creates an ask (sell) IoC order for 0.1 ETH
+  - along w/ the order, it sets up a Stop Loss (SL) and a Take Profit (TP) order for the whole size of the order
+  - the size of the SL/TP will be equal to the executed size of the order
+  - the SL/TP orders are canceled when the sign of your position changes
+
+- `create_position_tied_sl_tp.py`
+  - creates a bid (buy) Stop Loss (SL) and a Take Profit (TP) to close your short position
+  - the size of the orders will be for your whole position (because BaseAmount=0)
+  - the orders will grow / shrink as you accumulate more position
+  - the SL/TP orders are canceled when the sign of your position changes
+
+## On SL/TP orders
+SL/TP orders need to be configured beyond just setting the trigger price. When the trigger price is set, 
+the order will just be executed, like a normal order. This means that a market order, for example, might not have enough slippage! \
+Let's say that you have a 1 BTC long position, and the current price is $110'000. \
+You want to set up a take profit at $120'000
+- order should be an ask (sell) order, to close your position
+- the trigger price should be $120'000
+
+What about the order types? Just as normal orders, SL/TP orders trigger an order, which can be:
+- market order
+- limit IOC / GTC
+
+## Modify leverage / Margin Mode (Cross, Isolated) / Add Collateral to isolated-only positions
+- `margin_eth_20x_cross_http`
+  - sets ETH market to 20x leverage and cross-margin mode, using HTTP
+- `margin_eth_50x_isolate_ws`
+  - sets ETH market to 50x leverage and isolated margin mode, using HTTP
+- `margin_eth_add_collateral_http.py`
+  - adds $10.5 USDC to the ETH position (must be opened and in isolated mode)
+- `margin_eth_remove_collateral_ws.py`
+  - removes $5 USDC from the ETH position (must be opened and in isolated mode)
+
+## Batch orders
+- `send_batch_tx_http.py`
+  - sends multiple orders in a single HTTP request
+- `send_batch_tx_ws.py`
+  - sends multiple orders in a single WS request`
+
+Batch TXs will be executed back to back, without the possibility of other TXs interfering.
+
+## Spot Trading
+To trade spot markets, you need to have spot USDC. USDC used in your perpetual account will be used as collateral for your cross-positions.  
+USDC deposited in the spot account can only be used to buy spot assets.  
+To transfer USDC between spot <> perp balance, or vice verse, check out
+- `spot_self_transfer_perp_spot.py`
+- `spot_self_transfer_spot_perp.py`
+
+Order placement / trades work in the same way as for perpetual markets.  
+The fee will be paid in the received asset for premium spot trades.   
+This means that if you sell ETH, you'll receive less USDC, and if you BUY 1 ETH, you'll receive slightly less than 1 ETH.  
+You can check out the following examples, which should work on spot ETH by changing the market index to 2048 instead of 0.
+- `create_modify_cancel_order_http.py`
+- `create_modify_cancel_order_ws.py`
+- `create_market_order_eth_buy.py`
+- `create_market_order_eth_sell.py`
+- `send_batch_tx_http.py`
+- `send_batch_tx_ws.py`
+
+Trading setup is very similar to perpetual markets.  
+The only difference is that you'll need to hold USDC / ETH before placing an order.  
+For example, on perp markets you can place an order to short (sell) ETH without having to worry that much.    
+The limitation there would be to have enough available collateral to cover the order.  
+On spot orders, you need to have enough assets in your spot account to cover all open orders.  
+If you want to place two orders, to buy 1000 USDC worth of ETH and 1000 USDC worth of ZK, you'll need to have at least 2000 available USDC.  
+
+You can get the order book details (including symbol and market index) as well as quote asset id (ETH) and base asset id (USDC)  
+by following the example below:
+- `spot_get_order_books.py`
+
+Note: you'll need the quote asset id and base asset id to check available balance.  
+Available balance is not locked in open orders.
+
+To keep track of your spot balance, you can use HTTP calls or a websocket subscription.  
+Examples on how to do this can be found here:
+- `spot_get_account_assets_http.py`
+- `spot_get_account_assets_ws.py`
+
+Moving money to / from subaccounts is possible for spot assets. 
+For USDC, you can move directly from main perp balance to subaccount spot balance, for example.
+More details can be found in the following example:
+- `sub_account_create.py`
+- `sub_account_transfer_eth.py`
+- `sub_account_transfer_usdc.py`
+
+## Public Pools
+Public pools behave just like subaccounts, except that anyone can join them.  
+You can create / modify a public pool using the SDK. Check out the following example:
+- `public_pool_create_modify.py` 
+
+To create API keys for a public pool, you need to run the setup script but specify the `ACCOUNT_INDEX` to be the one of the public pool.  
+After that, you can trade from the public as from any other account.
+
+If you want to deposit / withdraw from a public pool, check the following example:
+- `public_pool_deposit.py`
+- `public_pool_withdraw.py`
+
+To get information about pools, check:
+- `public_pool_info.py`
+
+## Moving funds around
+- `withdraw_fast.py`
+  - send USDC directly from Lighter to Arbitrum
+- `withdraw_normal.py`
+  - send USDC/ETH from Lighter to Ethereum
+- `transfer.py`
+  - generic example of how to transfer funds between accounts.
+  - same functionality as `sub_account_transfer_eth` and `sub_account_transfer_usdc`
+
+## Transfer Notes
+The `memo` field is a user message, and it has to be exactly 32 bytes long. In case of fast withdrawals, you need to specify the recipient in the memo.  
+This is the case since the memo is part of the signature. This way, the recipient is verified.   
+
+When calling `client.transfer`, you pass the amount without needing to worry about the decimals.   
+When calling `client.sign_transfer` on the other hand, you need to specify the decimals and pass an integer.  
+
+The `fee` field can be obtained by calling `info_api.transfer_fee_info(...)`. The field can be passed as it is.  
+Transfers between subaccounts are free for all assets.
+
+When sending assets, you can specify the source and destination routes.  
+A route is either `perp` or `spot`. You can send USDC directly from your perp balance to another person's spot balance.  
+If you receive USDC in your perp account, it will be instantly used as collateral for open positions.  
+This also allows you to move USDC from your spot balance to your perp balance.  
+Spot assets (like ETH) need to have both the from and to route set to `spot`. 
+You can get all `asset_id`s by following the example below: 
+- `spot_get_order_books.py`

 ## Setup steps for mainnet
 - deposit money on Lighter to create an account first
@@ -1,70 +0,0 @@
-import asyncio
-import logging
-import lighter
-
-logging.basicConfig(level=logging.DEBUG)
-
-# The API_KEY_PRIVATE_KEY provided belongs to a dummy account registered on Testnet.
-# It was generated using the setup_system.py script, and servers as an example.
-# Alternatively, you can go to https://app.lighter.xyz/apikeys for mainnet api keys
-BASE_URL = "https://testnet.zklighter.elliot.ai"
-API_KEY_PRIVATE_KEY = "0xed636277f3753b6c0275f7a28c2678a7f3a95655e09deaebec15179b50c5da7f903152e50f594f7b"
-ACCOUNT_INDEX = 65
-API_KEY_INDEX = 1
-
-
-def trim_exception(e: Exception) -> str:
-    return str(e).strip().split("\n")[-1]
-
-
-async def main():
-    api_client = lighter.ApiClient(configuration=lighter.Configuration(host=BASE_URL))
-
-    client = lighter.SignerClient(
-        url=BASE_URL,
-        private_key=API_KEY_PRIVATE_KEY,
-        account_index=ACCOUNT_INDEX,
-        api_key_index=API_KEY_INDEX,
-    )
-
-    err = client.check_client()
-    if err is not None:
-        print(f"CheckClient error: {trim_exception(err)}")
-        return
-
-    # create order
-    tx, tx_hash, err = await client.create_order(
-        market_index=0,
-        client_order_index=123,
-        base_amount=100000,
-        price=405000,
-        is_ask=True,
-        order_type=lighter.SignerClient.ORDER_TYPE_LIMIT,
-        time_in_force=lighter.SignerClient.ORDER_TIME_IN_FORCE_GOOD_TILL_TIME,
-        reduce_only=0,
-        trigger_price=0,
-    )
-    print(f"Create Order {tx=} {tx_hash=} {err=}")
-    if err is not None:
-        raise Exception(err)
-
-    auth, err = client.create_auth_token_with_expiry(lighter.SignerClient.DEFAULT_10_MIN_AUTH_EXPIRY)
-    print(f"{auth=}")
-    if err is not None:
-        raise Exception(err)
-
-    # cancel order
-    tx, tx_hash, err = await client.cancel_order(
-        market_index=0,
-        order_index=123,
-    )
-    print(f"Cancel Order {tx=} {tx_hash=} {err=}")
-    if err is not None:
-        raise Exception(err)
-
-    await client.close()
-    await api_client.close()
-
-
-if __name__ == "__main__":
-    asyncio.run(main())
@@ -0,0 +1,69 @@
+import asyncio
+from lighter.signer_client import CreateOrderTxReq
+from utils import default_example_setup
+
+
+async def main():
+    client, api_client, _ = default_example_setup()
+
+    # Sell some ETH at $2500
+    # The size of the SL/TP orders will be equal to the size of the executed order
+
+    # set SL trigger price at 5000 and limit price at 5050
+    # set TP trigger price at 1500 and limit price at 1550
+    # Note: set the limit price to be higher than the SL/TP trigger price to ensure the order will be filled
+    # If the mark price of ETH reaches 1500, there might be no one willing to sell you ETH at 1500, so trying to buy at 1550 would increase the fill rate
+
+    ioc_order = CreateOrderTxReq(
+        MarketIndex=0,
+        ClientOrderIndex=0,
+        BaseAmount=1000,  # 0.1 ETH
+        Price=2500_00,  # $2500
+        IsAsk=1,  # sell
+        Type=client.ORDER_TYPE_LIMIT,
+        TimeInForce=client.ORDER_TIME_IN_FORCE_IMMEDIATE_OR_CANCEL,
+        ReduceOnly=0,
+        TriggerPrice=0,
+        OrderExpiry=0,
+    )
+
+    # Create a One-Cancels-the-Other grouped order with a take-profit and a stop-loss order
+    take_profit_order = CreateOrderTxReq(
+        MarketIndex=0,
+        ClientOrderIndex=0,
+        BaseAmount=0,
+        Price=1550_00,
+        IsAsk=0,
+        Type=client.ORDER_TYPE_TAKE_PROFIT_LIMIT,
+        TimeInForce=client.ORDER_TIME_IN_FORCE_GOOD_TILL_TIME,
+        ReduceOnly=1,
+        TriggerPrice=1500_00,
+        OrderExpiry=-1,
+    )
+
+    stop_loss_order = CreateOrderTxReq(
+        MarketIndex=0,
+        ClientOrderIndex=0,
+        BaseAmount=0,
+        Price=5050_00,
+        IsAsk=0,
+        Type=client.ORDER_TYPE_STOP_LOSS_LIMIT,
+        TimeInForce=client.ORDER_TIME_IN_FORCE_GOOD_TILL_TIME,
+        ReduceOnly=1,
+        TriggerPrice=5000_00,
+        OrderExpiry=-1,
+    )
+
+    transaction = await client.create_grouped_orders(
+        grouping_type=client.GROUPING_TYPE_ONE_TRIGGERS_A_ONE_CANCELS_THE_OTHER,
+        orders=[ioc_order, take_profit_order, stop_loss_order],
+    )
+
+    print("Create Grouped Order Tx:", transaction)
+
+    await client.close()
+    await api_client.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
@@ -1,39 +0,0 @@
-import asyncio
-import logging
-import lighter
-
-logging.basicConfig(level=logging.DEBUG)
-
-# The API_KEY_PRIVATE_KEY provided belongs to a dummy account registered on Testnet.
-# It was generated using the setup_system.py script, and serves as an example.
-BASE_URL = "https://testnet.zklighter.elliot.ai"
-API_KEY_PRIVATE_KEY = "0xed636277f3753b6c0275f7a28c2678a7f3a95655e09deaebec15179b50c5da7f903152e50f594f7b"
-ACCOUNT_INDEX = 65
-API_KEY_INDEX = 3
-
-
-def trim_exception(e: Exception) -> str:
-    return str(e).strip().split("\n")[-1]
-
-
-async def main():
-    client = lighter.SignerClient(
-        url=BASE_URL,
-        private_key=API_KEY_PRIVATE_KEY,
-        account_index=ACCOUNT_INDEX,
-        api_key_index=API_KEY_INDEX,
-    )
-
-    tx = await client.create_market_order(
-        market_index=0,
-        client_order_index=0,
-        base_amount=1000,  # 0.1 ETH
-        avg_execution_price=170000,  # $1700 -- worst acceptable price for the order
-        is_ask=True,
-    )
-    print("Create Order Tx:", tx)
-    await client.close()
-
-
-if __name__ == "__main__":
-    asyncio.run(main())
@@ -0,0 +1,28 @@
+import asyncio
+from utils import default_example_setup
+
+
+async def main():
+    client, api_client, _ = default_example_setup()
+    client.check_client()
+
+    # Note: change this to 2048 to trade spot ETH. Make sure you have at least 0.1 ETH to trade spot.
+    market_index = 0
+
+    tx, tx_hash, err = await client.create_market_order(
+        market_index=market_index,
+        client_order_index=0,
+        base_amount=1000,  # 0.1 ETH
+        avg_execution_price=4000_00,  # $4000 -- worst acceptable price for the order
+        is_ask=False,
+    )
+    print(f"Create Order {tx=} {tx_hash=} {err=}")
+    if err is not None:
+        raise Exception(err)
+
+    await client.close()
+    await api_client.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
@@ -0,0 +1,28 @@
+import asyncio
+from utils import default_example_setup
+
+
+async def main():
+    client, api_client, _ = default_example_setup()
+    client.check_client()
+
+    # Note: change this to 2048 to trade spot ETH. Make sure you have at least 0.1 ETH to trade spot.
+    market_index = 0
+
+    tx, tx_hash, err = await client.create_market_order(
+        market_index=market_index,
+        client_order_index=0,
+        base_amount=1000,  # 0.1 ETH
+        avg_execution_price=1700_00,  # $1700 -- worst acceptable price for the order
+        is_ask=True,
+    )
+    print(f"Create Order {tx=} {tx_hash=} {err=}")
+    if err is not None:
+        raise Exception(err)
+
+    await client.close()
+    await api_client.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
@@ -1,33 +1,21 @@
 import asyncio
-import logging
-import lighter
-
-logging.basicConfig(level=logging.DEBUG)
-
-# The API_KEY_PRIVATE_KEY provided belongs to a dummy account registered on Testnet.
-# It was generated using the setup_system.py script, and serves as an example.
-BASE_URL = "https://testnet.zklighter.elliot.ai"
-API_KEY_PRIVATE_KEY = "0xe0fa55e11d6b5575d54c0500bd2f3b240221ae90241e3b573f2307e27de20c04ea628de3f1936e56"
-ACCOUNT_INDEX = 22
-API_KEY_INDEX = 3
-
-
-def trim_exception(e: Exception) -> str:
-    return str(e).strip().split("\n")[-1]
+from utils import default_example_setup


 async def main():
-    client = lighter.SignerClient(
-        url=BASE_URL,
-        private_key=API_KEY_PRIVATE_KEY,
-        account_index=ACCOUNT_INDEX,
-        api_key_index=API_KEY_INDEX,
-    )
+    client, api_client, _ = default_example_setup()

    # tx = await client.create_market_order_limited_slippage(market_index=0, client_order_index=0, base_amount=30000000,
    #                                                        max_slippage=0.001, is_ask=True)
-    tx = await client.create_market_order_if_slippage(market_index=0, client_order_index=0, base_amount=30000000,
-                                                           max_slippage=0.01, is_ask=True, ideal_price=300000)
+    tx = await client.create_market_order_if_slippage(
+        market_index=0,  # ETH
+        client_order_index=0,
+        base_amount=1000,  # 0.1 ETH
+        max_slippage=0.01,  # 1%
+        is_ask=True,
+        ideal_price=300000  # $3000
+    )
+
    print("Create Order Tx:", tx)
    await client.close()

@@ -0,0 +1,65 @@
+import asyncio
+from utils import default_example_setup
+
+
+async def main():
+    client, api_client, _ = default_example_setup()
+    client.check_client()
+
+    # Note: change this to 2048 to trade spot ETH. Make sure you have at least 0.1 ETH to trade spot.
+    market_index = 0
+
+    # create order
+    api_key_index, nonce = client.nonce_manager.next_nonce()
+    tx, tx_hash, err = await client.create_order(
+        market_index=market_index,
+        client_order_index=123,
+        base_amount=1000,  # 0.1 ETH
+        price=4050_00,  # $4050
+        is_ask=True,
+        order_type=client.ORDER_TYPE_LIMIT,
+        time_in_force=client.ORDER_TIME_IN_FORCE_GOOD_TILL_TIME,
+        reduce_only=False,
+        trigger_price=0,
+        nonce=nonce,
+        api_key_index=api_key_index,
+    )
+    print(f"Create Order {tx=} {tx_hash=} {err=}")
+    if err is not None:
+        raise Exception(err)
+
+    ## modify order
+    # use the same API key so the TX goes after the create order TX
+    api_key_index, nonce = client.nonce_manager.next_nonce(api_key_index)
+    tx, tx_hash, err = await client.modify_order(
+        market_index=market_index,
+        order_index=123,
+        base_amount=1100,  # 0.11 ETH
+        price=4100_00,  # $4100
+        trigger_price=0,
+        nonce=nonce,
+        api_key_index=api_key_index,
+    )
+    print(f"Modify Order {tx=} {tx_hash=} {err=}")
+    if err is not None:
+        raise Exception(err)
+
+    ## cancel order
+    # use the same API key so the TX goes after the modify order TX
+    api_key_index, nonce = client.nonce_manager.next_nonce(api_key_index)
+    tx, tx_hash, err = await client.cancel_order(
+        market_index=market_index,
+        order_index=123,
+        nonce=nonce,
+        api_key_index=api_key_index,
+    )
+    print(f"Cancel Order {tx=} {tx_hash=} {err=}")
+    if err is not None:
+        raise Exception(err)
+
+    await client.close()
+    await api_client.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
@@ -0,0 +1,72 @@
+import websockets
+import asyncio
+from utils import default_example_setup, ws_send_tx
+
+
+# this example does the same thing as the create_modify_cancel_order.py example, but sends the TX over WS instead of HTTP
+async def main():
+    client, api_client, ws_client_promise = default_example_setup()
+    client.check_client()
+
+    # set up WS client and print a connected message
+    ws_client: websockets.ClientConnection = await ws_client_promise
+    print("Received:", await ws_client.recv())
+
+    # Note: change this to 2048 to trade spot ETH. Make sure you have at least 0.1 ETH to trade spot.
+    market_index = 0
+
+    # create order
+    api_key_index, nonce = client.nonce_manager.next_nonce()
+    tx_type, tx_info, tx_hash, err = client.sign_create_order(
+        market_index=market_index,
+        client_order_index=123,
+        base_amount=1000,  # 0.1 ETH
+        price=4050_00,  # $4050
+        is_ask=True,
+        order_type=client.ORDER_TYPE_LIMIT,
+        time_in_force=client.ORDER_TIME_IN_FORCE_GOOD_TILL_TIME,
+        reduce_only=False,
+        trigger_price=0,
+        nonce=nonce,
+        api_key_index=api_key_index,
+    )
+    if err is not None:
+        raise Exception(err)
+    await ws_send_tx(ws_client, tx_type, tx_info, tx_hash)
+
+    ## modify order
+    # use the same API key so the TX goes after the create order TX
+    api_key_index, nonce = client.nonce_manager.next_nonce(api_key_index)
+    tx_type, tx_info, tx_hash, err = client.sign_modify_order(
+        market_index=market_index,
+        order_index=123,
+        base_amount=1100,  # 0.11 ETH
+        price=4100_00,  # $4100
+        trigger_price=0,
+        nonce=nonce,
+        api_key_index=api_key_index,
+    )
+    if err is not None:
+        raise Exception(err)
+    await ws_send_tx(ws_client, tx_type, tx_info, tx_hash)
+
+    ## cancel order
+    # use the same API key so the TX goes after the modify order TX
+    api_key_index, nonce = client.nonce_manager.next_nonce(api_key_index)
+    tx_type, tx_info, tx_hash, err = client.sign_cancel_order(
+        market_index=market_index,
+        order_index=123,
+        nonce=nonce,
+        api_key_index=api_key_index,
+    )
+    if err is not None:
+        raise Exception(err)
+    await ws_send_tx(ws_client, tx_type, tx_info, tx_hash)
+
+    await client.close()
+    await api_client.close()
+    await ws_client.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
@@ -0,0 +1,56 @@
+import asyncio
+from lighter.signer_client import CreateOrderTxReq
+from utils import default_example_setup
+
+
+async def main():
+    client, api_client, _ = default_example_setup()
+
+    # Creates a position tied SL/TP pair
+    # The SL/TP orders will close your whole position, even if you add/remove from it later on
+    # if the positions reach 0 or switches from short -> long, the orders are canceled
+
+    # this particular example, sets the SL/TP for a short position
+    # set SL trigger price at 5000 and limit price at 5050
+    # set TP trigger price at 1500 and limit price at 1550
+    # Note: set the limit price to be higher than the SL/TP trigger price to ensure the order will be filled
+    # If the mark price of ETH reaches 1500, there might be no one willing to sell you ETH at 1500, so trying to buy at 1550 would increase the fill rate
+
+    # Create a One-Cancels-the-Other grouped order with a take-profit and a stop-loss order
+    take_profit_order = CreateOrderTxReq(
+        MarketIndex=0,
+        ClientOrderIndex=0,
+        BaseAmount=0,
+        Price=1550_00,
+        IsAsk=0,
+        Type=client.ORDER_TYPE_TAKE_PROFIT_LIMIT,
+        TimeInForce=client.ORDER_TIME_IN_FORCE_GOOD_TILL_TIME,
+        ReduceOnly=1,
+        TriggerPrice=1500_00,
+        OrderExpiry=-1,
+    )
+
+    stop_loss_order = CreateOrderTxReq(
+        MarketIndex=0,
+        ClientOrderIndex=0,
+        BaseAmount=0,
+        Price=4050_00,
+        IsAsk=0,
+        Type=client.ORDER_TYPE_STOP_LOSS_LIMIT,
+        TimeInForce=client.ORDER_TIME_IN_FORCE_GOOD_TILL_TIME,
+        ReduceOnly=1,
+        TriggerPrice=4000_00,
+        OrderExpiry=-1,
+    )
+
+    transaction = await client.create_grouped_orders(
+        grouping_type=client.GROUPING_TYPE_ONE_CANCELS_THE_OTHER,
+        orders=[take_profit_order, stop_loss_order],
+    )
+
+    print("Create Grouped Order Tx:", transaction)
+    await client.close()
+    await api_client.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
@@ -1,70 +0,0 @@
-import asyncio
-import logging
-import lighter
-
-logging.basicConfig(level=logging.DEBUG)
-
-# The API_KEY_PRIVATE_KEY provided belongs to a dummy account registered on Testnet.
-# It was generated using the setup_system.py script, and servers as an example.
-BASE_URL = "https://testnet.zklighter.elliot.ai"
-API_KEY_PRIVATE_KEY = "0xe0fa55e11d6b5575d54c0500bd2f3b240221ae90241e3b573f2307e27de20c04ea628de3f1936e56"
-ACCOUNT_INDEX = 22
-API_KEY_INDEX = 3
-
-
-def trim_exception(e: Exception) -> str:
-    return str(e).strip().split("\n")[-1]
-
-
-async def main():
-    client = lighter.SignerClient(
-        url=BASE_URL,
-        private_key=API_KEY_PRIVATE_KEY,
-        account_index=ACCOUNT_INDEX,
-        api_key_index=API_KEY_INDEX,
-    )
-
-    tx = await client.create_tp_order(
-        market_index=0,
-        client_order_index=0,
-        base_amount=1000,  # 0.1 ETH
-        trigger_price=500000,
-        price=500000,
-        is_ask=False
-    )
-    print("Create Order Tx:", tx)
-
-
-    tx = await client.create_sl_order(
-        market_index=0,
-        client_order_index=0,
-        base_amount=1000,  # 0.1 ETH
-        trigger_price=500000,
-        price=500000,
-        is_ask=False
-    )
-    print("Create Order Tx:", tx)
-
-    tx = await client.create_tp_limit_order(
-        market_index=0,
-        client_order_index=0,
-        base_amount=1000,  # 0.1 ETH
-        trigger_price=500000,
-        price=500000,
-        is_ask=False
-    )
-
-    tx = await client.create_sl_limit_order(
-        market_index=0,
-        client_order_index=0,
-        base_amount=1000,  # 0.1 ETH
-        trigger_price=500000,
-        price=500000,
-        is_ask=False
-    )
-    print("Create Order Tx:", tx)
-    await client.close()
-
-
-if __name__ == "__main__":
-    asyncio.run(main())
@@ -1,47 +1,30 @@
+import time
 import asyncio
-import lighter
-
-
-BASE_URL = "https://testnet.zklighter.elliot.ai"
-# use examples/system_setup.py or the apikeys page (for mainnet) to generate new api keys
-KEYS = {
-    5: "API_PRIVATE_KEY_5",
-    6: "API_PRIVATE_KEY_6",
-    7: "API_PRIVATE_KEY_7",
-}
-ACCOUNT_INDEX = 100  # replace with your account_index
+from utils import default_example_setup


 async def main():
-    client = lighter.SignerClient(
-        url=BASE_URL,
-        private_key=KEYS[5],
-        account_index=ACCOUNT_INDEX,
-        api_key_index=5,
-        max_api_key_index=7,
-        private_keys=KEYS,
-    )
+    client, api_client, _ = default_example_setup()

-    err = client.check_client()
-    if err is not None:
-        print(f"CheckClient error: {err}")
-        return
+    # create 20 orders. The client will use as many API keys as it was configured.

    for i in range(20):
        res_tuple = await client.create_order(
            market_index=0,
            client_order_index=123 + i,
-            base_amount=100000 + i,
-            price=385000 + i,
+            base_amount=1000 + i,  # 0.1 ETH + dust
+            price=3850_00 + i,
            is_ask=True,
-            order_type=lighter.SignerClient.ORDER_TYPE_LIMIT,
-            time_in_force=lighter.SignerClient.ORDER_TIME_IN_FORCE_GOOD_TILL_TIME,
-            reduce_only=0,
+            order_type=client.ORDER_TYPE_LIMIT,
+            time_in_force=client.ORDER_TIME_IN_FORCE_GOOD_TILL_TIME,
+            reduce_only=False,
            trigger_price=0,
        )
        print(res_tuple)

-    await client.cancel_all_orders(time_in_force=client.CANCEL_ALL_TIF_IMMEDIATE, time=0)
+    # wait for orders to be created
+    time.sleep(1)
+    await client.cancel_all_orders(time_in_force=client.CANCEL_ALL_TIF_IMMEDIATE, timestamp_ms=0)


 if __name__ == "__main__":
@@ -76,6 +76,10 @@ async def transaction_apis(client: lighter.ApiClient):
    # await print_api(transaction_instance.tx, by="sequence_index", value="5")
    await print_api(transaction_instance.txs, index=0, limit=2)
    
+async def funding_apis(client: lighter.ApiClient):
+    logging.info("FUNDING APIS")
+    account_instance = lighter.FundingApi(client)
+    await print_api(account_instance.funding_rates)

 async def main():
    client = lighter.ApiClient(configuration=lighter.Configuration(host="https://testnet.zklighter.elliot.ai"))
@@ -84,6 +88,7 @@ async def main():
    await candlestick_apis(client)
    await order_apis(client)
    await transaction_apis(client)
+    await funding_apis(client)
    await client.close()


@@ -0,0 +1,29 @@
+import asyncio
+from utils import default_example_setup
+
+
+async def main():
+    client, api_client, _ = default_example_setup()
+
+    # Note: the HTTP method `update_leverage` receives `leverage` as the argument,
+    # while the WS one that calls `sign_update_leverage` to get the TX to send it directly over WS
+    # receives `fraction` as the argument, which is 10_000 / leverage
+    # this was kept this way to not break backwards compatibility. Ideally, they would be consistent.
+
+    tx, tx_hash, err = await client.update_leverage(
+        market_index=0,
+        leverage=20,
+        margin_mode=client.CROSS_MARGIN_MODE
+    )
+
+    print(f"Update Leverage {tx=} {tx_hash=} {err=}")
+    if err is not None:
+        raise Exception(err)
+
+    await client.close()
+    await api_client.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+
@@ -0,0 +1,33 @@
+import websockets
+import asyncio
+from utils import default_example_setup, ws_send_tx
+
+
+async def main():
+    client, api_client, ws_client_promise = default_example_setup()
+
+    # set up WS client and print a connected message
+    ws_client: websockets.ClientConnection = await ws_client_promise
+    print("Received:", await ws_client.recv())
+
+    # Note: the HTTP method `update_leverage` receives `leverage` as the argument,
+    # while the WS one that calls `sign_update_leverage` to get the TX to send it directly over WS
+    # receives `fraction` as the argument, which is 10_000 / leverage
+    # this was kept this way to not break backwards compatibility. Ideally, they would be consistent.
+
+    tx_type, tx_info, tx_hash, err = client.sign_update_leverage(
+        market_index=0,
+        fraction=10_000 // 50,
+        margin_mode=client.ISOLATED_MARGIN_MODE
+    )
+    if err is not None:
+        raise Exception(err)
+    await ws_send_tx(ws_client, tx_type, tx_info, tx_hash)
+
+    await client.close()
+    await api_client.close()
+    await ws_client.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
@@ -0,0 +1,29 @@
+import asyncio
+from utils import default_example_setup
+
+
+async def main():
+    client, api_client, _ = default_example_setup()
+
+    # Note: the HTTP method `update_margin` receives `usdc_amount` (float) as the argument,
+    # while the WS one that calls `sign_update_margin` to get the TX to send it directly over WS
+    # receives `usdc_amount` (int) as the argument, which is the float one * 1_000_000
+    # this was kept this way to not break backwards compatibility. Ideally, they would be consistent.
+
+    tx, tx_hash, err = await client.update_margin(
+        market_index=0,
+        usdc_amount=10.5,
+        direction=client.ISOLATED_MARGIN_ADD_COLLATERAL
+    )
+
+    print(f"Update Margin {tx=} {tx_hash=} {err=}")
+    if err is not None:
+        raise Exception(err)
+
+    await client.close()
+    await api_client.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+
@@ -0,0 +1,32 @@
+import asyncio
+import websockets
+from utils import default_example_setup, ws_send_tx
+
+
+async def main():
+    client, api_client, ws_client_promise = default_example_setup()
+
+    # set up WS client and print a connected message
+    ws_client: websockets.ClientConnection = await ws_client_promise
+    print("Received:", await ws_client.recv())
+
+    # Note: the HTTP method `update_margin` receives `usdc_amount` (float) as the argument,
+    # while the WS one that calls `sign_update_margin` to get the TX to send it directly over WS
+    # receives `usdc_amount` (int) as the argument, which is the float one * 1_000_000
+    # this was kept this way to not break backwards compatibility. Ideally, they would be consistent.
+
+    tx_type, tx_info, tx_hash, err = client.sign_update_margin(
+        market_index=0,
+        usdc_amount=5_000_000,  # 5 USDC
+        direction=client.ISOLATED_MARGIN_REMOVE_COLLATERAL
+    )
+    if err is not None:
+        raise Exception(err)
+    await ws_send_tx(ws_client, tx_type, tx_info, tx_hash)
+
+    await client.close()
+    await api_client.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
@@ -0,0 +1,59 @@
+import time
+import json
+import asyncio
+import lighter
+from utils import default_example_setup
+
+
+async def main():
+    client, api_client, _ = default_example_setup()
+    tx_api = lighter.TransactionApi(api_client)
+
+    err = client.check_client()
+    if err is not None:
+        print(f"CheckClient error: {err}")
+        return
+
+    auth, _ = client.create_auth_token_with_expiry()
+
+    # create a public pool
+    tx_info, response, err = await client.create_public_pool(
+        operator_fee=100000,  # 10%
+        initial_total_shares=1_000_000,  # 1000 USDC
+        min_operator_share_rate=100,  # 1%
+    )
+    if err is not None:
+        raise Exception(f'failed to create public pool {err}')
+    tx_hash = response.tx_hash
+    print(f"✅ send create public pool tx. hash: {tx_hash}")
+
+    # fetch pool account index from tx hash
+    pool_account_index = -1
+    for i in range(10):
+        time.sleep(1)
+        try:
+            response = await tx_api.tx(by="hash", value=tx_hash)
+            event_info_j = json.loads(response.event_info)
+            pool_account_index = event_info_j['a']
+        except Exception as e:
+            pass
+        if pool_account_index != -1:
+            break
+    if pool_account_index == -1:
+        raise Exception(f"failed to find pool account index for tx {tx_hash}")
+    print(f"✅ pool account index: {pool_account_index}")
+
+    # Note: ❗️operator_fee can only decrease
+    # modify pool metadata
+    tx_info, response, err = await client.update_public_pool(
+        public_pool_index=pool_account_index,
+        status=0,  # 0 is active | 1 is frozen
+        operator_fee=50000,  # 5%
+        min_operator_share_rate=1000,  # 10%
+    )
+    if err is not None:
+        raise Exception(f'failed to create update pool {err}')
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
discountry	5f79b134f2	refactor: restructure Lighter SDK by removing deprecated Go files and enhancing Python documentation with new examples and models	2025-12-07 19:14:56 +08:00
discountry	85705dd27c	chore: update referral links in README files for Lighter and Aster	2025-11-29 01:57:44 +08:00
discountry	59ccd1fea8	feat: implement client ping/pong mechanism in LighterGateway for improved WebSocket connection health	2025-11-13 02:53:23 +08:00
discountry	a9fa7f2e19	feat: add bid, ask, and mark price to AsterTicker and normalize order status in LighterGateway	2025-11-13 02:34:10 +08:00
discountry	7529de334f	feat: implement position pruning and tracking in LighterGateway to manage stale positions and improve data integrity	2025-11-13 02:29:36 +08:00
discountry	1bfe4d58c0	refactor: streamline position handling in LighterGateway by removing unnecessary HTTP empty position logic and improving logging for empty position scenarios	2025-11-13 02:13:52 +08:00
discountry	4ce2b07e21	refactor: adjust feed staleness timeout and check intervals in LighterGateway for optimized monitoring and connection management	2025-11-13 02:05:29 +08:00
discountry	6bb0994cae	fix: ensure stale monitoring is stopped on WebSocket error and closure events in LighterGateway for improved connection management	2025-11-13 01:16:03 +08:00
discountry	486b911bed	feat: implement feed staleness monitoring in LighterGateway to enhance connection reliability and update handling	2025-11-12 23:57:21 +08:00
discountry	f48371ccd8	feat: add priceDecimals to MakerEngine and OffsetMakerEngine for improved price formatting in MakerApp and OffsetMakerApp	2025-11-12 21:24:16 +08:00
discountry	9ca35584b5	feat: add 'canceled-reduce-only' status to TERMINAL_ORDER_STATUSES in LighterGateway for comprehensive order status management	2025-11-12 21:08:35 +08:00
discountry	01e5ab9997	feat: add price viability checks and ensure maker price adjustments in OffsetMakerEngine for improved order handling	2025-11-12 20:45:29 +08:00
discountry	28bc1d5210	feat: improve error handling in OffsetMakerEngine and enhance logging in LighterGateway for better debugging and robustness	2025-11-12 20:34:02 +08:00
discountry	870fe2b8d7	feat: enhance order error handling in OffsetMakerEngine and update LighterGateway order status types for improved robustness	2025-11-12 19:35:31 +08:00
discountry	e7f6341961	feat: enhance order handling in LighterGateway and introduce order identity normalization for improved precision and consistency	2025-11-12 19:17:04 +08:00
discountry	1baee3a207	feat: add Guardian strategy to manage existing positions with stop loss and trailing stop functionality	2025-11-09 14:09:54 +08:00
discountry	e94cf1bda2	feat: enhance toAccountSnapshot function with improved market ID and symbol matching logic, and add corresponding unit tests	2025-11-08 17:14:01 +08:00
discountry	274e2f3d75	fix: improve WebSocket close reason normalization in LighterGateway for better error handling	2025-11-08 12:10:47 +08:00
discountry	a91e87534b	refactor: streamline order handling logic in LighterGateway by consolidating market ID checks and improving snapshot order clearing	2025-11-08 12:09:27 +08:00
discountry	d0d1afa0ea	feat: enhance quantity and price rounding functions for improved precision in trading calculations	2025-11-06 21:06:03 +08:00
discountry	0f70c6b6aa	feat: enhance WebSocket documentation and improve LighterGateway position handling for better account management	2025-11-06 18:47:29 +08:00
discountry	078b201d15	feat: implement getPrecision method in AsterExchangeAdapter and enhance AsterGateway for precision handling in order normalization	2025-11-04 22:10:45 +08:00
discountry	1832c4c13e	feat: add scaleQuantityWithMinimum function to normalize order quantities and implement corresponding tests	2025-11-03 21:30:19 +08:00
discountry	73a88a8a0f	fix: improve order price comparison logic in makeOrderPlan function for better precision	2025-10-28 18:59:37 +08:00
discountry	265cb6df50	feat: enhance close position handling in AsterRestClient to support STOP_MARKET and TAKE_PROFIT_MARKET types	2025-10-28 12:50:31 +08:00
discountry	5bba8169b5	feat: enhance precision synchronization in trading strategies and improve order quantity normalization logic	2025-10-27 18:42:44 +08:00
discountry	295c6a47b7	fix: reverse Kline entries in mapKlines function to maintain chronological order	2025-10-23 20:01:49 +08:00
discountry	e7dedbba2c	chore: update referral links in README files for Backpack and add Apex referral link	2025-10-23 19:56:44 +08:00
discountry	6196912cf4	fix: ensure order IDs are consistently treated as strings and configure ed25519 to use custom sha512 implementation	2025-10-23 19:45:19 +08:00
discountry	f1ebfacaa2	feat: update dependencies and add ccxt documentation for new features	2025-10-23 19:36:42 +08:00
discountry	ea5da20311	feat: 重构订单路由逻辑，添加订单意图类型以支持多交易所订单处理	2025-10-23 14:04:44 +08:00
discountry	fabc8af679	feat: 更新市场平仓逻辑，添加数量参数并调整reduceOnly处理以符合交易所要求	2025-10-12 10:16:14 +08:00
discountry	189fed0f6e	feat: 更新止损订单逻辑，添加数量步进和触发类型处理以符合交易所要求	2025-10-11 22:05:50 +08:00
discountry	09ff4dc296	feat: 移除不必要的数量参数，优化止损和市价平仓订单逻辑以确保精确处理	2025-10-11 21:45:56 +08:00
discountry	2627fa9db8	feat: 优化订单去重和取消逻辑，确保在处理STOP订单时避免精度损失	2025-10-11 21:41:39 +08:00
discountry	8b20e60753	feat: 更新止损订单逻辑，针对Aster期货调整reduceOnly参数处理以符合交易所要求	2025-10-11 21:27:37 +08:00
discountry	f991215d86	feat: 优化订单创建和止损逻辑，确保参数处理符合交易所要求	2025-10-09 20:18:13 +08:00
discountry	6a3b842a3b	feat: 优化平仓订单逻辑，避免在止损订单中下调数量，确保精确传递给交易所	2025-10-08 20:05:02 +08:00
discountry	b36c1dce0f	feat: 优化Paradex网关的订单金额处理逻辑，确保在平仓时仅对市场订单省略金额参数	2025-10-08 20:00:08 +08:00
discountry	dbe8df6934	feat: 优化平仓逻辑，确保正确处理订单数量并提示交易所关闭整个仓位	2025-10-08 19:55:51 +08:00
discountry	400c7ad4b7	feat: 优化Paradex网关的订单金额处理逻辑，确保平仓时正确传递金额参数	2025-10-08 19:53:44 +08:00
discountry	e96cbb6ff4	feat: 更新Paradex网关，添加平仓逻辑以优化订单金额处理	2025-10-08 19:48:25 +08:00
discountry	aa3d5e8c6c	feat: 更新网格引擎，添加跳过去重参数以优化新订单下单逻辑	2025-10-08 05:44:10 +08:00
discountry	96cf4ea47b	feat: 更新网格引擎，优化新订单下单逻辑，合并快照更新与冷却期条件以提升下单效率	2025-10-08 04:59:21 +08:00
discountry	45061ed748	feat: 更新网格引擎，添加订单版本控制与冷却机制以优化新订单下单逻辑	2025-10-08 04:58:11 +08:00
discountry	da3dacb549	feat: 更新网格引擎，添加时间戳以跟踪等待订单状态，优化新订单下单逻辑以避免重复下单	2025-10-08 04:56:04 +08:00
discountry	51e0ce2bea	feat: 更新网格引擎，添加启动撤单未完成时的处理逻辑，优化撤单与新订单的交互	2025-10-08 04:48:24 +08:00
discountry	8c13d20cb7	feat: 更新网格引擎，添加平仓优先逻辑以确保在持有仓位时正确处理撤单与新订单	2025-10-08 04:44:48 +08:00
discountry	3d959ae579	feat: 更新网格引擎，修复订单处理逻辑中的布尔参数，确保正确的撤单处理	2025-10-08 04:38:22 +08:00
discountry	4240cc6901	feat: 更新网格引擎，添加启动撤单处理逻辑，优化初始平仓时的订单处理与抑制机制	2025-10-08 04:32:22 +08:00
discountry	8d0e9578c4	feat: 更新网格引擎，优化买卖订单处理逻辑，添加相同价格出口意图检查以避免意图冲突	2025-10-08 04:23:30 +08:00
discountry	95f07145a9	feat: 更新网格引擎，添加键级抑制机制以优化订单处理，支持处理已知与未知意图的订单	2025-10-08 04:19:23 +08:00
discountry	e3411c6791	feat: 更新网格引擎，增强日志记录以优化订单处理逻辑，添加跳过条件的详细信息	2025-10-08 03:51:29 +08:00
discountry	640f1bfb4e	feat: 更新网格引擎，增强入口数量限制逻辑，支持按买卖方向分别计算待处理订单数量	2025-10-08 03:43:47 +08:00
discountry	f973fe433d	feat: 更新网格引擎，添加等待分类机制以处理账户快照后的订单状态，优化入口数量限制与订单过滤逻辑	2025-10-08 03:38:21 +08:00
discountry	730a75df93	feat: 更新网格引擎，移除未使用的函数与临时阻塞逻辑，增强订单意图管理与出口数量限制以优化订单处理	2025-10-08 03:03:24 +08:00
discountry	de8a793bd5	feat: 更新网格引擎，增强订单意图管理与消失订单处理逻辑，添加入口与出口意图支持以优化订单分类	2025-10-08 02:48:06 +08:00
discountry	bb072b2d1d	feat: 更新网格引擎，添加跳过去重选项以优化订单处理逻辑	2025-10-08 02:38:01 +08:00
discountry	95426e222b	feat: 更新网格引擎，优化订单处理逻辑，添加计划订单计数与唯一性检查以提升订单管理效率	2025-10-08 02:34:37 +08:00
discountry	4365d73562	feat: 更新网格引擎，移除减仓订单相关逻辑，优化即时平仓订单处理与状态管理	2025-10-08 02:32:07 +08:00
discountry	6067f759a0	feat: 更新网格引擎，增强即时平仓订单处理逻辑，添加减仓订单支持以优化利润捕获	2025-10-08 02:11:31 +08:00
discountry	b31b98f816	feat: 更新网格引擎，添加即时平仓订单队列以优化订单处理逻辑	2025-10-08 01:55:05 +08:00
discountry	801543488e	feat: 更新网格引擎，优化等待分类机制，增强账户快照确认逻辑以处理消失订单	2025-10-08 01:45:12 +08:00
discountry	20c73eba21	feat: 更新网格引擎，添加等待分类机制以处理消失订单，优化订单状态确认逻辑	2025-10-08 00:14:12 +08:00
discountry	ed49dca2a6	feat: 更新网格引擎，增强订单消失分类处理逻辑，添加临时阻塞机制以避免重复开仓	2025-10-07 23:57:29 +08:00
discountry	ca559d0f82	feat: 更新网格引擎，进一步简化状态管理，移除持久化逻辑，优化订单处理与目标检测	2025-10-07 22:34:05 +08:00
discountry	fef7604490	feat: 更新网格引擎，增强订单消失处理逻辑，优化平仓订单管理与目标检测	2025-10-07 22:26:32 +08:00
discountry	e524c225f2	feat: 更新网格引擎，重构订单处理逻辑，移除减仓订单相关处理，增强平仓订单管理	2025-10-07 22:15:47 +08:00
discountry	39a97110dd	feat: 更新网格引擎，优化订单填充检测逻辑，增强对历史键和元数据的比较处理	2025-10-07 22:00:43 +08:00
discountry	8ad19b007b	feat: 更新基础套利引擎，使用扣费后价差计算入场机会并优化日志信息	2025-10-07 16:31:26 +08:00
discountry	2e2990369b	feat: 更新基础套利引擎，添加市场就绪时间逻辑，优化信号评估以使用快照数据	2025-10-07 16:29:09 +08:00
discountry	24f93fa8a7	feat: 更新基础套利引擎，添加资金收益和手续费计算逻辑，优化信号评估功能并更新UI以显示相关信息	2025-10-07 16:23:53 +08:00
discountry	d778e20c23	feat: 添加现货和合约账户余额获取功能至基础套利引擎，更新UI以显示账户余额信息	2025-10-07 16:06:14 +08:00
discountry	58f5de4a48	feat: 添加资金费率获取功能至基础套利引擎，更新UI以显示资金费率信息	2025-10-07 15:56:50 +08:00
discountry	ad46635e20	feat: 更新网格引擎，添加绝对持仓量跟踪逻辑，优化锚定价格选择和订单消失分类处理	2025-10-07 15:30:28 +08:00
discountry	6dde78f799	feat: 更新网格引擎，简化状态管理和订单处理逻辑，移除持久化和曝光映射，优化初始平仓处理	2025-10-07 15:18:15 +08:00
discountry	6b70aa0936	feat: 更新网格引擎，优化平仓逻辑以独立处理减仓订单，增强买卖档位映射管理	2025-10-07 14:12:32 +08:00
discountry	66e1b3e6f5	feat: 更新网格引擎，添加现有减仓订单恢复逻辑，优化订单曝光管理和状态同步功能	2025-10-07 04:41:32 +08:00
discountry	c6f279c51b	feat: 更新网格引擎，优化平仓逻辑以处理实际持仓情况，确保安全平仓数量计算	2025-10-07 04:16:33 +08:00
discountry	9bad7f180e	feat: 更新网格引擎，添加新逻辑以处理无持仓和无挂单状态，优化网格状态清理和初始侧分配功能	2025-10-07 04:09:06 +08:00
discountry	88292c9c49	feat: 添加最大平仓滑点配置，更新网格引擎状态持久化逻辑，优化订单管理和状态恢复功能	2025-10-07 03:48:12 +08:00
discountry	5878a3dc0b	feat: 更新网格引擎，重构订单管理逻辑，添加持仓水平和关闭目标管理，优化订单计算和曝光对齐处理	2025-10-07 03:24:09 +08:00
discountry	ccb23ecf44	feat: 更新网格引擎，添加买卖水平索引以稳定订单侧分配，增强订单计算逻辑	2025-10-07 02:54:01 +08:00
discountry	b6a6515677	feat: 增强网格引擎逻辑，添加持仓水平管理和订单书更新功能，优化订单取消和曝光对齐处理	2025-10-07 02:15:23 +08:00
discountry	5e65c7025d	feat: 添加基础网格策略支持，更新环境配置示例和文档，增强 CLI 和 UI 界面	2025-10-07 01:40:06 +08:00
discountry	d7a95ceb36	feat: 添加期现套利策略支持，更新相关配置和界面，增强 Aster 现货 API 客户端功能	2025-10-07 00:23:24 +08:00
discountry	1bd3e7edc6	feat: 更新 README 文件，优化项目描述，添加多交易所支持信息和环境变量配置指南	2025-10-06 20:32:49 +08:00
discountry	28ba0613ca	feat: 更新 .env.example 和 README.md，添加 Paradex 相关环境变量和手续费优惠注册链接	2025-10-06 20:19:11 +08:00
discountry	1dce3dfcfb	feat: 更新 README.md，添加 Binance、Backpack 和 edgex 手续费优惠注册链接	2025-10-06 20:16:52 +08:00
discountry	d829e451cd	feat: 更新 BackpackGateway 适配器，增强账户快照逻辑，支持合约市场的持仓信息和资产归一化处理	2025-10-06 20:11:46 +08:00