Skip to main content
This section describes the built-in accounts system of Injective.
This document describes the built-in accounts system of Injective.Pre-requisite Readings:
Injective defines its custom Account type that uses Ethereum’s ECDSA secp256k1 curve for keys. This satisfies the EIP84 for full BIP44 paths. The root HD path for Injective-based accounts is m/44'/60'/0'/0.

​
Addresses and Public Keys

There are 3 main types of Addresses/PubKeys available by default on Injective:
  • Addresses and Keys for accounts, that identify users (i.e., the sender of a message). They are derived using the eth_secp256k1 curve.
  • Addresses and Keys for validator operators, which identify the operators of validators. They are derived using the eth_secp256k1 curve.
  • Addresses and Keys for consensus nodes, which identify the validator nodes participating in consensus. They are derived using the ed25519 curve.
Address bech32 PrefixPubkey bech32 PrefixCurveAddress byte lengthPubkey byte length
Accountsinjinjpubeth_secp256k12033 (compressed)
Validator Operatorinjvaloperinjvaloperpubeth_secp256k12033 (compressed)
Consensus Nodesinjvalconsinjvalconspubed255192032

​
Address formats for clients

EthAccounts can be represented in both Bech32 and hex format for Ethereum’s Web3 tooling compatibility. The Bech32 format is the default format for Cosmos-SDK queries and transactions through CLI and REST clients. The hex format is the Ethereum common.Address representation of a Cosmos sdk.AccAddress.
  • Address (Bech32): inj14au322k9munkmx5wrchz9q30juf5wjgz2cfqku
  • Address (EIP55 Hex): 0xAF79152AC5dF276D9A8e1E2E22822f9713474902
  • Compressed Public Key: {"@type":"/injective.crypto.v1beta1.ethsecp256k1.PubKey","key":"ApNNebT58zlZxO2yjHiRTJ7a7ufjIzeq5HhLrbmtg9Y/"}
You can query an account address using the Cosmos CLI or REST clients: 
# NOTE: the --output (-o) flag will define the output format in JSON or YAML (text)
injectived q auth account $(injectived keys show <MYKEY> -a) -o text
|
  '@type': /injective.types.v1beta1.EthAccount
  base_account:
    account_number: "3"
    address: inj14au322k9munkmx5wrchz9q30juf5wjgz2cfqku
    pub_key: null
    sequence: "0"
  code_hash: xdJGAYb3IzySfn2y3McDwOUAtlPKgic7e/rYBF2FpHA=

# GET /cosmos/auth/v1beta1/accounts/{address}
curl -X GET "http://localhost:10337/cosmos/auth/v1beta1/accounts/inj14au322k9munkmx5wrchz9q30juf5wjgz2cfqku" -H "accept: application/json"
See the Swagger API reference for the full docs on the accounts API.
The Cosmos SDK Keyring output (i.e injectived keys) only supports addresses in Bech32 format.

​
Derive Injective Account from a private key/mnemonic

Below is an example of how to derive an Injective Account from a private key and/or a mnemonic phrase: 
import { Wallet } from 'ethers'
import { Address as EthereumUtilsAddress } from 'ethereumjs-util'

const mnemonic = "indoor dish desk flag debris potato excuse depart ticket judge file exit"
const privateKey = "afdfd9c3d2095ef696594f6cedcae59e72dcd697e2a7521b1578140422a4f890"
const defaultDerivationPath = "m/44'/60'/0'/0/0"
const defaultBech32Prefix = 'inj'
const isPrivateKey: boolean = true /* just for the example */

const wallet = isPrivateKey ? Wallet.fromMnemonic(mnemonic, defaultDerivationPath) : new Wallet(privateKey)
const ethereumAddress = wallet.address
const addressBuffer = EthereumUtilsAddress.fromString(ethereumAddress.toString()).toBuffer()
const injectiveAddress = bech32.encode(defaultBech32Prefix, bech32.toWords(addressBuffer))
Below is an example of how to derive a public key from a private key: 
import secp256k1 from 'secp256k1'

const privateKey = "afdfd9c3d2095ef696594f6cedcae59e72dcd697e2a7521b1578140422a4f890"
const privateKeyHex = Buffer.from(privateKey.toString(), 'hex')
const publicKeyByte = secp256k1.publicKeyCreate(privateKeyHex)

const buf1 = Buffer.from([10])
const buf2 = Buffer.from([publicKeyByte.length])
const buf3 = Buffer.from(publicKeyByte)

const publicKey = Buffer.concat([buf1, buf2, buf3]).toString('base64')
const type = '/injective.crypto.v1beta1.ethsecp256k1.PubKey'

​
Subaccounts

Injective subaccounts allow a single main wallet address to manage multiple, isolated trading accounts. This is useful for power users, especially professional traders and market makers.
For technical implementation details on subaccounts, see the Trading Account developer documentation.

​
Key features and explanation

  • Programmatic access: This feature is designed to be highly accessible for programmatic trading via Injective’s native APIs, catering to financial application developers.
  • Advanced account management: The subaccounts feature provides sophisticated account management capabilities, enabling users (e.g., institutions or algorithmic traders) to segregate funds and trading strategies within a single, primary Injective address.
  • Isolation and organization: Funds and orders within one subaccount are isolated from others, which is critical for managing risk, running different trading bots, or applying distinct strategies simultaneously without interference.
  • Seamless transfers: Users can easily transfer assets between their main account balance and their various subaccounts, as well as between different subaccounts, using specific messages on the Injective network.
  • Integration with exchange modules: The subaccounts functionality is part of Injective’s core exchange module, which includes an on-chain order book and matching engine for spot, perpetual, futures, and options markets.
Subaccounts function like separate, linked “portfolios” controlled by a single user account. This provides flexibility and operational control for participants in Injective’s DeFi ecosystem.