Quickstart

git clone https://github.com/InjectiveLabs/injective-rfq-toolkit.git
cd injective-rfq-toolkit
python -m venv .venv && source .venv/bin/activate
pip install -U pip
pip install -e ".[dev]"

cd injective-rfq-toolkit/examples
npm install

RFQ_ENV=testnet
TESTNET_RETAIL_PRIVATE_KEY=0x...   # your taker wallet private key

import os
from rfq_test.clients.chain import ChainClient
from rfq_test.config import get_environment_config
from rfq_test.utils.setup import RETAIL_AUTHZ_GRANTS, setup_authz_grants
from rfq_test.crypto.wallet import Wallet

TAKER_PRIVATE_KEY = os.environ["TESTNET_RETAIL_PRIVATE_KEY"]

config = get_environment_config()
chain = ChainClient(config.chain)
await chain.connect()

taker = Wallet.from_private_key(TAKER_PRIVATE_KEY)

await setup_authz_grants(
    chain_client=chain,
    wallet=taker,
    contract_address=config.contract.address,
    msg_types=RETAIL_AUTHZ_GRANTS,
)
await chain.close()

import time
import uuid
from rfq_test.clients.websocket import TakerStreamClient

taker_ws = TakerStreamClient(
    config.indexer.ws_endpoint,
    request_address=taker.inj_address,
    auth_private_key=TAKER_PRIVATE_KEY,
    auth_contract_address=config.contract.address,
    timeout=10.0,
)
await taker_ws.connect()

auth_result = await taker_ws.wait_for_auth_result(timeout=10.0)
if not auth_result["authenticated"]:
    raise RuntimeError(
        f"TakerStream auth failed: {auth_result['code']}: {auth_result['message']}"
    )

expiry_ms = int(time.time() * 1000) + 5 * 60 * 1000

request_data = {
    "request_address": taker.inj_address,
    "client_id": str(uuid.uuid4()),
    "market_id": config.default_market.id,
    "direction": "long",                  # lowercase string
    "margin": "200",
    "quantity": "100",
    "worst_price": "5",                   # hard price limit
    "expiry": expiry_ms,                  # 5 minutes from now
}

ack = await taker_ws.send_request(
    request_data,
    wait_for_response=True,
    response_timeout=5.0,
)
rfq_id = int(ack["rfq_id"])               # indexer-assigned id

import WebSocket from "ws";

const ws = new WebSocket(
  "wss://testnet.rfq.ws.injective.network/injective_rfq_rpc.InjectiveRfqRPC/TakerStream",
);
const clientId = crypto.randomUUID();
const expiry = Date.now() + 5 * 60 * 1000;

const request = {
  type: "rfq_request",
  client_id: clientId,
  market_id: INJUSDC_MARKET_ID,
  direction: "long",                    // lowercase string – NOT an integer
  margin: "200",
  quantity: "100",
  worst_price: "5",
  request_address: takerInjAddress,
  expiry,
};

// Complete the v1 TakerStream challenge-response handshake first.
ws.send(JSON.stringify(request));

const ack = await waitForRequestAck(ws, clientId);
const rfqId = Number(ack.rfq_id);

quotes = await taker_ws.collect_quotes(
    rfq_id=rfq_id,
    timeout=0.5,           # TrueCurrent uses 500ms; API takers may tune this
    min_quotes=1,
)

if not quotes:
    raise RuntimeError("No quotes received within window")

best = min(quotes, key=lambda q: float(q["price"]))
print(f"Best: {best['price']} from {best['maker']}")

const quotes: Quote[] = [];

ws.on("message", (raw: Buffer) => {
  const msg = JSON.parse(raw.toString());
  if (msg.type === "rfq_quote" && msg.rfq_id === rfqId) {
    quotes.push(msg);
  }
});

await new Promise((r) => setTimeout(r, 500)); // TrueCurrent default; tune for API use

const best = quotes.sort(
  (a, b) => Number(a.price) - Number(b.price),
)[0];

from decimal import Decimal
from rfq_test.clients.contract import ContractClient
from rfq_test.models.types import Direction

contract = ContractClient(config.contract, config.chain)

contract_quote = {
    "maker": best["maker"],
    "margin": best["margin"],
    "quantity": best["quantity"],
    "price": best["price"],
    "expiry": int(best["expiry"]),         # defensive cast – client wraps to {"ts": ...}
    "signature": best["signature"],        # hex with 0x prefix – client converts to base64
}

tx_hash = await contract.accept_quote(
    private_key=TAKER_PRIVATE_KEY,
    quotes=[contract_quote],
    rfq_id=str(rfq_id),
    market_id=config.default_market.id,
    direction=Direction.LONG,
    margin=Decimal("200"),
    quantity=Decimal("100"),
    worst_price=Decimal("5"),
    unfilled_action=None,                  # RFQ-only; current product does not expose orderbook fallback
)

print(f"Settled: {tx_hash}")

import { MsgExecuteContractCompat, MsgBroadcasterWithPk } from "@injectivelabs/sdk-ts";

// Contract expects base64, indexer delivers hex
const signatureB64 = Buffer.from(
  best.signature.replace(/^0x/, ""),
  "hex",
).toString("base64");

const msg = MsgExecuteContractCompat.fromJSON({
  sender: takerInjAddress,
  contractAddress: CONTRACT_ADDRESS,
  msg: {
    accept_quote: {
      rfq_id: rfqId,                       // NUMBER, not string
      market_id: INJUSDC_MARKET_ID,
      direction: "long",                   // lowercase STRING for contract
      margin: "200",
      quantity: "100",
      worst_price: "5",
      quotes: [
        {
          maker: best.maker,
          margin: best.margin,
          quantity: best.quantity,
          price: best.price,
          expiry: { ts: Number(best.expiry) },   // wrap + defensive cast
          signature: signatureB64,               // base64
        },
      ],
      unfilled_action: null,
    },
  },
});

const broadcaster = new MsgBroadcasterWithPk({
  privateKey: RETAIL_PRIVATE_KEY,
  network: Network.TestnetSentry,
});

const { txHash } = await broadcaster.broadcast({ msgs: msg });
console.log("Settled:", txHash);