Injective Trader

Injective Trader is a professional-grade framework that provides a high-performance, reliable foundation for developing and deploying algorithmic trading strategies on the Injective blockchain. It bridges the gap between algorithmic trading strategies and blockchain execution, eliminating technical barriers. The framework takes care of the heavy lifting - real-time data streaming, order execution, reconnection/recovery, transaction batching, and analytics This frees up traders to focus solely on strategy development rather than blockchain complexities.

You can use it to import existing strategies or create new ones that:

Place orders automatically based on your logic
Monitor markets 24/7 and react to price changes
Manage risk with built-in limits and safety features
Handle multiple markets simultaneously
Provide detailed logs of all trading activity

Core Capabilities

Simplified Strategy Development

No SDK expertise required - focus purely on trading logic
Rapid strategy deployment with minimal technical overhead
Event-driven architecture enabling intuitive strategy implementation

Built-in Reliability

Automated reconnection and recovery mechanisms
Transaction validation before execution
Comprehensive error handling and retry logic

Performance Optimization

Intelligent transaction batching for cost reduction
Automatic fee management and optimization
Multi-account support for scale

Enterprise-Ready Features

Complete position and PnL tracking
Risk management capabilities
Detailed performance analytics

Injective trader transacts assets with real value, as such security is paramount. Be sure to use the following as a security baseline, and also take further measures to protect your assets.

Never share private keys or commit them to Git.
Store secrets in a local .env file and load via environment variables.
For extra safety, consider using AuthZ to grant trading rights without exposing your main account.

Quick Start (5 minutes)

1. Get Your Injective Account Ready (and Funded)

Create an account on Injective using Keplr or injectived.
If using Keplr, export your private key for the .env file.
- Tip: With AuthZ, you can grant limited permissions to a trading account for better security.
Fund your account with USDT by sending from another Injective address, or via bridge.injective.network.
- EVM tip: You can derive your inj address with the TS SDK and bridge USDT from Ethereum to Injective without even setting up an Injective account.

2. Download and Setup

git clone https://github.com/InjectiveLabs/injective-trader.git
cd injective-trader

# Create a virtual environment (recommended)
python3 -m venv .venv
source .venv/bin/activate    # Windows: .venv\Scripts\Activate.ps1

pip install -r requirements.txt
pip install "injective-py==1.9"

Note: injective-trader is not yet compatible with injective-py v1.11.

3. Configure Your Strategy

Edit the preexisting config.yaml:

Exchange: Helix
ConsoleLevel: INFO
FileLevel: DEBUG

Components:
  Initializer:
    Network: mainnet
    BotName: MyBot
    MarketTickers:
      - INJ/USDT PERP
      - BTC/USDT PERP
      - ETH/USDT PERP

Strategies:
  MyMarketMaker:
    Name: "MyMarketMaker"
    Class: "SimpleStrategy"
    MarketIds:
      - "0x17ef48032..."  # INJ/USDT PERP
      - "0x4ca0f92f..."  # BTC/USDT PERP
      - "0x9b998016..."  # ETH/USDT PERP
    AccountAddresses:
      - "inj1your_account_address_here"
    TradingAccount: "inj1your_account_address_here"
    CIDPrefix: "my_mm"
    Parameters:
      OrderSize: 0.1
      MaxPosition: 1.0
      SpreadThreshold: 0.005

4. Set Your Private Key

Instead of a single INJECTIVE_PRIVATE_KEY, use bot-scoped environment variables in .env (matches the framework defaults):

# For bot named "MyBot"
MyBot_GRANTER_INJECTIVE_PRIVATE_KEY=your_granter_private_key_here
MyBot_GRANTEE_0_INJECTIVE_PRIVATE_KEY=your_first_grantee_private_key_here

Load them into your session:

export $(grep -v '^#' .env | xargs)

5. Run Your Strategy

python main.py MyBot config.yaml --log_path logs/my_bot.log --network mainnet

That's it - your bot is now live!

IDE set up

If you are using VS code or compatible IDEs (such as Cursor), consider adding the following configuration for easy debugging.

.vscode/launch.json:

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Run MyBot (mainnet)",
      "type": "python",
      "request": "launch",
      "program": "${workspaceFolder}/main.py",
      "console": "integratedTerminal",
      "args": ["MyBot", "config.yaml", "--log_path", "logs/strategy.log", "--network", "mainnet"],
      "envFile": "${workspaceFolder}/.env"
    },
    {
      "name": "Run MyBot (testnet, debug)",
      "type": "python",
      "request": "launch",
      "program": "${workspaceFolder}/main.py",
      "console": "integratedTerminal",
      "args": ["MyBot", "config.yaml", "--log_path", "logs/debug.log", "--network", "testnet", "--debug"],
      "envFile": "${workspaceFolder}/.env"
    }
  ]
}

You should now be able to do Run → Start Debugging in your IDE.

Architecture

System Architecture Diagram

Core Design Patterns

Mediator Pattern: Centralizes communication between components, enabling a decoupled architecture where components interact without direct dependencies.
Component Pattern: Standardizes lifecycle management (initialize, run, terminate) for all system components, ensuring consistent behavior.
State Pattern: Manages component lifecycle through well-defined states (Idle, Running, Terminated), providing predictable transitions and error handling.
Task Management Pattern: Coordinates asynchronous tasks with automated monitoring and recovery, ensuring reliable execution in an event-driven environment.
Observer Pattern: Enables strategies to react to specific update events through specialized event handlers, creating a flexible strategy development approach.

Key Components

Exchange-Specific Agents

Initializer: Sets up exchange connections, accounts, and markets
ChainListener: Streams real-time blockchain data with automatic reconnection
MessageBroadcaster: Handles transaction creation and broadcasting with retry logic
Liquidator: Monitors and executes liquidations for undercollateralized positions

Managers

MarketManager: Processes market data and maintains orderbook integrity
AccountManager: Tracks balances, positions, and order state
StrategyManager: Routes market events to appropriate strategy implementations
RiskManager: Enforces position limits and risk controls
TaskManager: Orchestrates and monitors asynchronous task execution

Data-Level Domains

Market: Represents trading pairs with orderbooks and metadata
Account: Manages account balances, deposits, and subaccounts
Positions: Tracks derivative positions with P&L calculations
Order: Order state tracking with execution history
Oracle Prices: Real-time price feeds with timestamp tracking

Strategy-Level Plugins

Strategy Base: Template for implementing custom strategies
Update Handlers: Event-specific processors for market data events
Performance Metrics: Statistics and P&L tracking
Risk Models: Customizable risk management rules

Learn more about the simple strategy that ships with Injective Trader, to get yourself comfortable with the codebase before diving in.

PreviousProvider Oracle NextGetting Started

Last updated 12 hours ago