pip install frontrunner-sdk

from frontrunner_sdk import FrontrunnerSDK

# Create a synchronous Frontrunner SDK
# By default, this will use testnet; no "real" tokens will be involved.
sdk = FrontrunnerSDK()

# Creates a new wallet locally
# Requests funds from an injective faucet
create_wallet = sdk.injective.create_wallet()

# Save your wallet credentials
print(f"""
Put this somewhere safe!

    {create_wallet.wallet.mnemonic}

""")

Put this somewhere safe!

    bip39 bip39 bip39 bip39 bip39 bip39 bip39 bip39 bip39 bip39 bip39 bip39 bip39 bip39 bip39 bip39 bip39 bip39 bip39 bip39 bip39 bip39 bip39 bip39

find_markets = sdk.frontrunner.find_markets(
  sports=["basketball"], # Looking for basketball game markets
  event_types=["game"], # Looking for game (instead of future) markets
  prop_types=["winner"], # Looking for winner (instead of other) markets
  market_statuses=["active"], # Only active markets
)

# Pick a market
market = find_markets.markets[0]
print(f"Market: {market.long_entity_name} [{market.prop_name}] vs {market.short_entity_name}")

Market: New York Knicks [Winner] vs Cleveland Cavaliers

# get the order book for this market
response = sdk.injective.get_order_books([market.injective_id])
order_book = response.order_books[market.injective_id]

# Frontrunner testnet markets are in FRCOIN and on Injective, FRCOIN has 6 decimals.
# 1,000,000 from Injective is $1 FRCOIN.
FRCOIN_SCALE_FACTOR = 10 ** 6

# print order book buys
print("buys:")
for buy in order_book.buys:
  print(f"  {buy.quantity} @ ${int(buy.price) / FRCOIN_SCALE_FACTOR}")

# print order book sells
print("sells:")
for sell in order_book.sells:
  print(f"  {sell.quantity} @ ${int(sell.price) / FRCOIN_SCALE_FACTOR}")

# find the highest buy and lowest sell
buy_prices = [int(order.price) / FRCOIN_SCALE_FACTOR for order in order_book.buys]
sell_prices = [int(order.price) / FRCOIN_SCALE_FACTOR for order in order_book.sells]
highest_buy, lowest_sell = max(buy_prices), min(sell_prices)
print(f"bid-ask spread: [${highest_buy}, ${lowest_sell}]")

buys:
  5882 @ $0.34
  9091 @ $0.33
  15625 @ $0.32
  5000 @ $0.1
sells:
  4364 @ $0.36
  8108 @ $0.37
  13158 @ $0.38
bid-ask spread: [$0.34, $0.36]

from frontrunner_sdk.models import Order

highest_buy = 0.01
injective_id = "0xd03091c74e4e76878c2afbeb470b1c825677014afdaa3d315fa534884d2d90e1"

create_orders = sdk.injective.create_orders([
    Order.buy_long(injective_id, 10, highest_buy + 0.01),
    Order.buy_long(injective_id, 5, highest_buy + 0.02),
])

print(f"""
Transaction: {create_orders.transaction}

You can view your transaction at:

  https://testnet.explorer.injective.network/transaction/{create_orders.transaction}
""")

Transaction: 917F980F001120A05642F225E9197CCDF1BB5677A6381F81D2CC95410466008C

You can view your transaction at:

  https://testnet.explorer.injective.network/transaction/917F980F001120A05642F225E9197CCDF1BB5677A6381F81D2CC95410466008C

get_orders = sdk.injective.get_orders(mine=True, execution_types=["limit"])

print("orders:")
for order_history in get_orders.orders:
  print(f"  {order_history.order_type} {order_history.order.order_hash}: {order_history.order.quantity} @ ${int(order_history.order.price) / FRCOIN_SCALE_FACTOR}")

orders:
  OrderType.BUY_LONG 0x642c138d85a8224093665d1c8bd4fc31e2307fcee62157c7175e5865ea850247: 5 @ $0.03
  OrderType.BUY_LONG 0xd82ced802fdf5ce55a1b37238d83ece7677e4aeb0d576ebb76d041a590ecff16: 10 @ $0.02

import logging

# Set logging for frontrunner-sdk to INFO and above
logging.getLogger("frontrunner_sdk").setLevel(logging.INFO)

# Only log critical errors from config and clients
logging.getLogger("frontrunner_sdk.clients").setLevel(logging.CRITICAL)
logging.getLogger("frontrunner_sdk.config").setLevel(logging.CRITICAL)

from frontrunner_sdk import FrontrunnerSDKAsync

sdk = FrontrunnerSDKAsync()

from frontrunner_sdk import FrontrunnerSDK

sdk = FrontrunnerSDK()

sdk = FrontrunnerSDK()

# SDK return values are always response objects
response = sdk.injective.some_list_operation()

# Desired values will be Within the response object
desired_value = response.desired_value
maybe_other_value = response.maybe_other_value

from frontrunner_sdk.models import Subaccount, Wallet

wallet = Wallet._new()

Subaccount.from_subaccount_id("0xb4efdbe3240d3d2a1bc6be8a1f717944e734a0dd000000000000000000000001")
wallet.subaccount(1)
Subaccount.from_injective_address_and_index("inj1knhahceyp57j5x7xh69p7utegnnnfgxavmahjr", 1)
Subaccount.from_ethereum_address_and_index("0xb4efdbe3240d3d2a1bc6be8a1f717944e734a0dd", 1)

import time
from typing import List

from frontrunner_sdk import FrontrunnerSDKAsync
from frontrunner_sdk.models import Order, OrderType

FRCOIN_SCALE_FACTOR = 10 ** 6


async def _print_orderbook(sdk: FrontrunnerSDKAsync, injective_market_id: str):
  response = await sdk.injective.get_order_books([injective_market_id])
  order_book = response.order_books[injective_market_id]

  print("buys:")
  for buy in order_book.buys:
    print(f"  {buy.quantity} @ ${int(buy.price) / FRCOIN_SCALE_FACTOR}")
  print("sells:")
  for sell in order_book.sells:
    print(f"  {sell.quantity} @ ${int(sell.price) / FRCOIN_SCALE_FACTOR}")

  buy_prices = [int(order.price) / FRCOIN_SCALE_FACTOR for order in order_book.buys]
  sell_prices = [int(order.price) / FRCOIN_SCALE_FACTOR for order in order_book.sells]
  highest_buy, lowest_sell = max(buy_prices) if buy_prices else 0, min(sell_prices) if sell_prices else 0
  print(f"bid-ask spread: [${highest_buy}, ${lowest_sell}]")

async def _print_orders(sdk: FrontrunnerSDKAsync, injective_market_id: str, subaccount_indexes: List[int]):
  for subaccount_index in subaccount_indexes:
    get_orders = await sdk.injective.get_orders(mine=True, market_ids=[injective_market_id], subaccount_index=subaccount_index)
    print(f"orders for index {subaccount_index}:")
    for order_history in get_orders.orders:
      print(f"{order_history.order_type} {order_history.order.state} : filled {order_history.order.filled_quantity} / {order_history.order.quantity} @ ${int(float(order_history.order.price)) / FRCOIN_SCALE_FACTOR}")

def calculate_price(probability: float, price_margin: float, order_type: OrderType):
  if order_type == OrderType.BUY_LONG:
    return round(max(0.01, min(0.99, probability - price_margin)), 2)
  else:
    return round(min(0.99, max(0.01, probability + price_margin)), 2)

def generate_histogram_orders(injective_market_id: str, total_value_coefficients: List[float], order_type: OrderType, price: float, price_step: float, total_value: float, subaccount_index: int):
  orders = []
  for coeff in total_value_coefficients:
    if price < 0.01 or price > 0.99:
      break
    coeff_total_value = total_value * coeff # total amount we want to spend on shares at this price
    num_shares = coeff_total_value / price # num_shares * price = total_value spent
    if order_type == OrderType.BUY_LONG:
      orders.append(Order.buy_long(injective_market_id, int(round(num_shares, 0)), round(price, 2), subaccount_index=subaccount_index))
    elif order_type == OrderType.BUY_SHORT:
      orders.append(Order.buy_short(injective_market_id, int(round(num_shares, 0)), round(price, 2), subaccount_index=subaccount_index))
    price += price_step
  return orders

async def main():
  total_value_coefficients = [0.2, 0.3, 0.5] # the distribution of funds for each price step; sum should always equal 1
  assert(int(sum(total_value_coefficients)) == 1)
  sdk = FrontrunnerSDKAsync()
  print(f"Running with wallet {(await sdk.wallet()).injective_address}")
  injective_market_id = "REPLACE_ME"

  wallet = await sdk.wallet()
  long_subaccount_index = 1
  short_subaccount_index = 2
  long_subaccount = wallet.subaccount_address(long_subaccount_index)
  short_subaccount = wallet.subaccount_address(short_subaccount_index)
  print(f"Running with wallet {wallet.injective_address}. {long_subaccount=}, {short_subaccount=}")

  response = await sdk.injective.fund_subaccount(1000, "FRCOIN", destination_subaccount_index=long_subaccount_index)
  print(f"View deposit transaction to long side subaccount: https://testnet.explorer.injective.network/transaction/{response.transaction}")

  response = await sdk.injective.fund_subaccount(1000, "FRCOIN", destination_subaccount_index=short_subaccount_index)
  print(f"View deposit transaction to short side subaccount: https://testnet.explorer.injective.network/transaction/{response.transaction}")

  probability = 0.68
  desired_total_liquidity = 100
  spread_per_side = 0.01
  long_base_price = calculate_price(probability, spread_per_side, OrderType.BUY_LONG)
  short_base_price = calculate_price(probability, spread_per_side, OrderType.BUY_SHORT)
  # Note this includes validation of the probability to prevent submitting orders at invalid prices.
  #   Instead, this case could be detected and a smaller histogram created.
  buy_long_orders = generate_histogram_orders(injective_market_id, total_value_coefficients, OrderType.BUY_LONG, long_base_price, -1 * spread_per_side, desired_total_liquidity / 2, long_subaccount_index) if probability >= 0.02 else []
  buy_short_orders = generate_histogram_orders(injective_market_id, total_value_coefficients, OrderType.BUY_SHORT, short_base_price, spread_per_side, desired_total_liquidity / 2, short_subaccount_index)  if probability <= 0.98 else []
  orders = buy_long_orders + buy_short_orders
  print(orders)
  response = await sdk.injective.create_orders(orders)
  print(f"View create orders transaction: https://testnet.explorer.injective.network/transaction/{response.transaction}")
  time.sleep(5)  # ensure new state is reflected
  await _print_orderbook(sdk, injective_market_id)
  await _print_orders(sdk, injective_market_id, list(range(3)))

# Find Frontrunner markets where...
response = sdk.frontrunner.find_markets(
  # ...the winner
  prop_type=["winner"],
  # ...of a basketball
  sports=["basketball"],
  # ...game
  event_types=["game"],
  # ...is the Los Angeles Lakers (LAL)
  sport_entity_abbreviations=["LAL"],
)

# Find Frontrunner markets where...
response = sdk.frontrunner.find_markets(
  # ...formula one
  sports=["formula1"],
  # ...team Williams or Alfa Romeo
  sport_entity_names=["Williams", "Alfa Romeo"],
  # ...is not for a 'winner' type prop
  prop_types=["other"],
)

# Get all active Frontrunner markets
response = sdk.frontrunner.find_markets()

for market in response.markets:
    print(f"Market: {market.address} [{market.long_entity_name} / {market.short_entity_name}]")

# Get all Frontrunner leagues
response = sdk.frontrunner.get_leagues()

print(f"Leagues: {response.leagues}")

from frontrunner_sdk.openapi.frontrunner_api import MarketStatus

# Get all active NFL markets
league_id = "c6c521c4-88d0-463d-aa2a-fe3765ec872a"
response = sdk.frontrunner.get_markets(
    league_id=league_id,
    status=MarketStatus.ACTIVE,
)

# Get all active Frontrunner markets
response = sdk.frontrunner.get_markets()

for market in response.markets:
    print(f"Market: {market.address} [{market.long_entity_name} / {market.short_entity_name}]")

# Get all NFL props
league_id = "c6c521c4-88d0-463d-aa2a-fe3765ec872a"
response = sdk.frontrunner.get_props(
    league_id=league_id,
)

# Get all Frontrunner props
response = sdk.frontrunner.get_props()

print(f"Props: {response.props}")

# Get all NFL sport entities
league_id = "c6c521c4-88d0-463d-aa2a-fe3765ec872a"
response = sdk.frontrunner.get_sport_entities(
    league_id=league_id,
)

# Get all Frontrunner sport entities
response = sdk.frontrunner.get_sport_entities()

print(f"Sport Entities: {response.sport_entities}")

# Get all NFL sport events
league_id = "c6c521c4-88d0-463d-aa2a-fe3765ec872a"
response = sdk.frontrunner.get_sport_events(
    league_id=league_id,
)

# Get all Frontrunner sport events
response = sdk.frontrunner.get_sport_events()

print(f"Sport Events: {response.sport_events}")

# Get all Frontrunner sports
response = sdk.frontrunner.get_sports()

print(f"Sports: {response.sports}")

# Cancel all your orders
response = sdk.injective.cancel_all_orders()

print("transaction:", response.transaction)
print("orders:")
for order in response.orders:
  print(f"\tmarket: {order.market_id[:12]}... price: {order.price} quantity: {order.quantity}")

# Cancel a single specific order
response = sdk.injective.cancel_orders([
  CancelOrder(
    market_id="0x141e3c92ed55107067ceb60ee412b86256cedef67b1227d6367b4cdf30c55a74",
    order_hash="znihpTtkWn/9Npy1Zzku+GNxXfyLE/k05U1KXRUTO1E=",
  ),
])

print("transaction:", response.transaction)

some_market = "0x141e3c92ed55107067ceb60ee412b86256cedef67b1227d6367b4cdf30c55a74"
other_market = "0x9181874b70fefe3e126b6472c6de647b4dbfa59025ad5dc61be6559532d19e15"

# Create orders 
# Note that this specific set of orders (both long and short buys) can't all be executed together due to subaccount
#   mechanics (see Subaccount Management for more details) and because sells only work with an existing position. 
#   This list of orders is just to demonstrate all types.
response = sdk.injective.create_orders([
  Order.buy_long(some_market, 120, 0.70),
  Order.sell_long(some_market, 100, 0.75),
  Order.buy_short(other_market, 30, 0.90),
  Order.sell_short(other_market, 25, 0.95),
])

print("transaction:", response.transaction)

for order in response.orders:
  print(
    "order:",
    order.market_id,
    "for", order.quantity, "@" order.price,
    "in subaccount", order.subaccount_index,
    "with hash", order.hash,
  )

from itertools import chain

create_orders = sdk.injective.create_orders([
  Order.buy_long(some_market, 120, 0.70),
  Order.sell_short(other_market, 25, 0.95),
])

# store order hashes
order_hashes = { order.hash: order for order in create_orders.orders }

get_transaction = sdk.injective.get_transaction(create_orders.transaction)

# find order failures and causes
order_failures = dict(chain.from_iterable(
  zip(order_failure.hashes, order_failure.flags)
  for order_failure
  in get_transaction.order_failures
))

# get (order, flag) correlated by hash
correlated_failed_orders = [
  (order_hashes[order_hash], flag)
  for order_hash, flag
  in order_failures.items()
  if order_hash in order_hashes
]

for order, flag in correlated_failed_orders:
  print("failed order:", order.market_id, order.quantity, "@", order.price, "flag =", flag)

response = sdk.injective.create_wallet()

print("wallet eth address:", response.wallet.ethereum_address)
print("wallet inj address:", response.wallet.injective_address)

print("wallet mnenomic (keep this safe):")
print("\n\t", response.wallet.mnemonic)
print("wallet private key (keep this safe):")
print("\n\t", response.wallet.private_key.to_hex())

external_subaccount = Subaccount.from_injective_address_and_index("inj1fjlfjy5adns4msjqch3vqjhesmwjnu9ep045wz", 1)
response = await sdk.injective.fund_external_subaccount(10, "FRCOIN", external_subaccount)

print("transaction:", response.transaction)

response = await sdk.injective.fund_external_wallet(10, "FRCOIN", "inj1fjlfjy5adns4msjqch3vqjhesmwjnu9ep045wz")

print("transaction:", response.transaction)

destination_subaccount_index = 2
wallet = await sdk.wallet()
destination_subaccount = wallet.subaccount(destination_subaccount_index)

# Equivalent methods of transferring from main bank balance to a subaccount
response = await sdk.injective.fund_subaccount(5, "FRCOIN", destination_subaccount_index=1)
response = await sdk.injective.fund_subaccount(5, "FRCOIN", destination_subaccount=destination_subaccount)

# Equivalent methods of transferring between subaccounts
response = await sdk.injective.fund_subaccount(5, "FRCOIN", source_subaccount_index=1, destination_subaccount_index=destination_subaccount_index)
response = await sdk.injective.fund_subaccount(5, "FRCOIN", source_subaccount_index=1, destination_subaccount=destination_subaccount)

print("transaction:", response.transaction)

response = sdk.injective.fund_wallet_from_faucet()

print("message:", response.message)

response = sdk.injective.get_account_portfolio()

print("portfolio bank balances:")
for coins in response.portfolio.bank_balances:
  print("\tcoin:", coins.amount, coins.denom)

print("portfolio subaccount balances:")
for subaccount in response.portfolio.subaccounts:
  print(
    "\tsubaccount:",
    subaccount.subaccount_id,
    subaccount.deposit.available_balance, "/", subaccount.deposit.available_balance,
    subaccount.denom,
  )

market_id = "0xd5e4b12b19ecf176e4e14b42944731c27677819d2ed93be4104ad7025529c7ff"

# Get order books for given market ids
response = sdk.injective.get_order_books([market_id])

print("order_books:")
for market_id, order_book in response.order_books.items():
  print("\tmarket:", market_id)

  for buy in order_book.buys:
    print("\t\tbuy:", buy.quantity, "@", buy.price)

  for sell in order_book.sells:
    print("\t\tsell:", sell.quantity, "@", sell.price)

# Get all my orders
response = sdk.injective.get_orders(mine=True)

print("orders:")
for order_history in response.orders:
  print(
    "order:",
    order_history.order_type,
    order_history.order.quantity, "@", order_history.order.trigger_price,
    order_history.order.order_hash,
  )

market_id = "0x90e662193fa29a3a7e6c07be4407c94833e762d9ee82136a2cc712d6b87d7de3"

# Get all buy positions
response = sdk.injective.get_positions(
  [market_id],
  direction="buy",
)

print("positions:", response.positions)

market_id = "0x90e662193fa29a3a7e6c07be4407c94833e762d9ee82136a2cc712d6b87d7de3"

# Get all trades on the maker side
response = sdk.injective.get_trades(
  [market_id],
  side="maker",
)

print("trades:", response.trades)

transaction_hash = "BAE72A64BE091B323F508F1887FAF4FA94C0EFE9348831C07DBB078CFC71E16A"

# Get all buy positions
response = sdk.injective.get_transaction(transaction_hash)

print("raw injective response:", response.injective_response)
print("order failures:", response.order_failures)

response = sdk.injective.refresh_wallet()

print("wallet sequence:", response.wallet.sequence)

async def run():
  market_id = "0x90e662193fa29a3a7e6c07be4407c94833e762d9ee82136a2cc712d6b87d7de3"

  response = async_sdk.injective.stream_markets([market_id])

async def run():
  response = ...

  async for market in response.markets:
      print(market)

async def run():
  market_id = "0x90e662193fa29a3a7e6c07be4407c94833e762d9ee82136a2cc712d6b87d7de3"

  response = async_sdk.injective.stream_orders(market_id)

async def run():
  response = ...

  async for order_history in response.orders:
    print("order:", order_history.order_type, order_history.order.order_hash)

async def run():
  response = async_sdk.injective.stream_positions()

async def run():
  response = ...

  async for position in response.positions:
    print(
      "position:",
      position.ticker,
      position.direction,
      position.quantity, "@", position.entry_price,
    )

async def run():
  market_id = "0x90e662193fa29a3a7e6c07be4407c94833e762d9ee82136a2cc712d6b87d7de3"

  response = async_sdk.injective.stream_trades(market_id)

async def run():
  response = async_sdk.injective.stream_trades(market_id)

  async for trade in response.trades:
    print("trade:", trade.operation_type, trade.trade.order_hash)

response = await sdk.injective.withdraw_from_subaccount(10, "FRCOIN", subaccount_index=1)

print("transaction:", response.transaction)

currency = sdk.utilities.currency_from_quantity(420_690_000, "FRCOIN")
print(
  "currency:",
  "[", currency.value, currency.denom.name, "]",
  "is represented as",
  "[", currency.quantity, currency.denom.peggy, "]",
  "in injective",
)

currency = sdk.utilities.currency_from_value(420.69, "FRCOIN")
print(
  "currency:",
  "[", currency.value, currency.denom.name, "]",
  "is represented as",
  "[", currency.quantity, currency.denom.peggy, "]",
  "in injective",
)