Trading Strategy has secured a grant from the Arbitrum DAO to deliver CCXT libraries for GMX on Arbitrum. The result is a familiar, Python-based exchange-agnostic interface that algorithmic traders use, now for one of the most used perpetual futures DEXes on the fast, cost-efficient layer two blockchain.
Why this matters
Quant teams and independent strategy developers already use standard interfaces of CCXT library to connect strategy code to tens of centralised crypto exchanges like Binance and Coinbase. Extending that unified API to GMX lowers integration overhead for research, backtesting, and live trade execution. If you are familiar with CCXT, you can easily point existing workflows to GMX with minimal customisation.
GMX offers onchain spot and perpetual futures markets with deep liquidity and an intuitive trading model, while Arbitrum provides high throughput and low fees. Bringing a CCXT-style interface to this environment helps strategy developers transition from prototype to production with less friction, and provides traders a familiar way to execute onchain.
GMX is one of the most popular DEXes in the Arbitrum ecosystem, driving onchain transactions and total value locked (TVL). By making GMX more accessible to professional quants and traders, it will be easier to convert quants currently trading on centralised exchanges into DeFi users, driving more Arbitrum onchain adoption.
What the grant covers
The approved grant proposal focuses on making GMX accessible through a CCXT-compatible interface, together with practical developer documentation. By aligning with CCXT conventions, core functions such as market discovery, order placement, account state, and historical data follow patterns that quants already use on a daily basis. The goal is to minimise switching costs and make it straightforward to plug GMX into existing alpha research and execution stacks.
The grant will be completed in two parts:
- Bringing the existing GMX Python library under the proper open source maintenance, making it easy to use and test GMX functions in a developer-friendly manner.
- Building a CCXT-compatible adapter on top of the GMX integration layer, which abstracts away onchain operations, offering a familiar automated trading API interface for traders to migrate from centralised exchanges effortlessly.
A code example of how to trade on GMX using Python:
# github.com/tradingstrategy-ai/web3-ethereum-defi
from eth_defi.gmx.create_increase_order import IncreaseOrder
from eth_defi.gmx.trading import GMXTrading
from eth_defi.provider.multi_provider import create_multi_provider_web3
from eth_defi.gmx.config import GMXConfig
from eth_defi.hotwallet import HotWallet
from eth_account import Account
import os
# Setup connection to Arbitrum
json_rpc_url = os.environ.get("JSON_RPC_ARBITRUM")
if not json_rpc_url:
json_rpc_url = input("Please enter your Arbitrum JSON-RPC URL: ")
web3 = create_multi_provider_web3(json_rpc_url)
config = GMXConfig(web3)
print(f"Connected to chain {web3.eth.chain_id}")
# initialise the trading manager
trading_manager = GMXTrading(config)
market_symbol = "ETH"
collateral_symbol = "USDC"
# Create a long position with USDC as collateral
# This will return a transaction object, which then need to be signed
# in order to get executed
increase_order_tx = trading_manager.open_position(
market_symbol=market_symbol,
collateral_symbol=collateral_symbol,
start_token_symbol=collateral_symbol,
is_long=True,
size_delta_usd=100,
leverage=2,
slippage_percent=0.003,
debug_mode=False,
execution_buffer=2.2,
)
private_key = os.environ.get("PRIVATE_KEY")
account = Account.from_key(private_key)
hot_wallet = HotWallet(account)
hot_wallet.sync_nonce(web3)
# This will sign the transaction
signed_tx = hot_wallet.sign_transaction(increase_order_tx)
# And finally send the transaction
tx_hash = web3.eth.send_transaction(signed_tx)
print(f"Trade broadcasted: {tx_hash}")How does this fit the Trading Strategy protocol?
Trading Strategy is a self-custodial algorithmic trading protocol for decentralised markets, combining data access, backtesting, integrations to thousands of DEXes, and verifiable onchain execution. CCXT-compatible access to GMX on Arbitrum complements that stack, providing strategy authors with another production-grade route to deploy systematic trading, now also on Perp DEXes.
What makes GMX special?
GMX is a perpetual futures (“perp”) DEX for EVM blockchains.
GMX offers dozens of perp trading pairs for popular cryptocurrencies like BTC, ETH and SOL. GMX is a so-called pure onchain market with a high degree of decentralisation. Thus, GMX has high composability with other decentralised finance protocols. This allows users longing and shorting different asset prices with leverage onchain.
GMX is one of the oldest pure onchain perpetual futures marketplaces still running. GMX mainly operates on Arbitrum, but has expanded to include cross-chain functionality. GMX saw a hacking incident in July 2025 from which it recovered.
GMX has its own pools for market making where pools user can provide liquidity and take the other side of the trade. There are GLP vaults in GMX v2 and older GLP vaults in GMX v1. GLV is the index pool of GMX’s markets, rebalancing liquidity to its best-performing GM pools and generating fees from them. As a result, GLV offers liquidity providers a balanced instrument with stable risk-adjusted returns and high capital efficiency.
There are multiple third-party DeFi vaults built on top of GMX, like Umami’s GM vaults which follow the ERC-4626 standard.
GMX price formation relies on its multi-asset liquidity pool (GLP) and a “virtual” AMM (vAMM) model, which utilises Chainlink oracles for price data instead of a traditional order book. When users trade, the vAMM calculates the price based on the ratio of assets in the GLP pool, and price feeds from Chainlink ensure accurate pricing for fixed-price trades. Unlike standard AMMs, GMX’s vAMM shifts risk to liquidity providers (LPs) in the GLP pool, with traders paying a fee that is split between the GMX token holders and the GLP LPs.
A first step toward broader perpetual futures DEX coverage
We are still working on the phase one of the grant: most of GMX low level functionality is covered.
GMX on Arbitrum is one of the first of several upcoming integrations to Perp DEXes. Standardised connectivity expands the surface area for strategy design, risk models, and execution research, so your focus stays on alpha, not plumbing.
If you build or run systematic strategies, this integration enables you to extend your universe to GMX with a familiar API on a high-performance chain. Follow our blog and developer getting started docs for integration guides, code examples, and updates as we roll out CCXT support for GMX on Arbitrum and expand to more Perp DEXes across the onchain landscape.