Glossary

A centralized reference for key technical terms used throughout this documentation, including Cosmos, EVM, wallets, smart contracts, and blockchain concepts.

A

ABCI (Application Blockchain Interface)
The protocol that allows the consensus engine (e.g. CometBFT) to communicate with the application logic in a Cosmos SDK blockchain. It lets developers implement application logic in any language that implements the interface.

ABI (Application Binary Interface)
A JSON specification that describes how to interact with a smart contract: its functions, events, and how to encode and decode arguments and return values. Wallets and dApps use the ABI to call contract functions correctly.

Account
A blockchain identity controlled by cryptographic keys. On EVM chains, accounts are either Externally Owned Accounts (EOAs) or contract accounts. On Cosmos, accounts are managed by the Cosmos SDK (e.g. Auth module).

Address
A string (often hex on EVM, Bech32 on Cosmos) that uniquely identifies an account or contract on a blockchain. Derived from a public key.

Auth Module
Cosmos SDK module that manages accounts, addresses, and authentication. It defines account types and how transactions are signed and validated.

B

Bank Module
Cosmos SDK module responsible for tracking token balances and multi-asset transfers across accounts.

Bech32
A checksummed encoding format used in Cosmos (e.g. cosmos1..., evmos1...) for addresses. It reduces errors when copying or sharing addresses.

Block
A batch of transactions that are ordered, validated, and appended to the blockchain ledger. Each block has a header (e.g. previous block hash, Merkle root) and a list of transactions.

Block Explorer
A web tool to inspect blocks, transactions, addresses, and smart contracts on a chain. Examples: WireScan, Etherscan, Ping.pub.

Block Height
The number of blocks in the chain from the genesis block. Used to reference a specific block and to track chain progress.

Bridge
A protocol or set of contracts that enables token or message transfers between different blockchain networks (e.g. EVM and Cosmos).

Bytecode
Compiled, low-level representation of a smart contract that the EVM executes. Generated by compilers like the Solidity compiler (solc).

C

Chain ID
A unique identifier for a blockchain network. Used to prevent replay attacks and to let wallets and dApps target the correct network (e.g. WireFluid Testnet uses Chain ID 92533).

Cold Wallet
A wallet that keeps private keys offline (e.g. hardware wallet or paper backup). Used for long-term storage and higher security.

CometBFT
The Byzantine Fault Tolerant (BFT) consensus engine used by Cosmos SDK chains. It handles block production, consensus, and P2P networking. Formerly known as Tendermint.

Consensus
The process by which network nodes agree on the next block and the canonical state. Cosmos chains typically use Tendermint-style BFT consensus (e.g. CometBFT).

Contract Account
On the EVM, an account controlled by code (a smart contract). It has no private key; its behavior is defined by its deployed bytecode.

Contract Address
The address where a smart contract is deployed on a blockchain. Used to call the contract’s functions.

Cosmos Hub
The first Cosmos SDK chain, acting as an interoperability hub between other Cosmos chains via IBC.

Cosmos SDK
A modular framework for building application-specific blockchains. It provides modules for staking, bank, governance, IBC, and more, with a focus on interoperability and customizability.

Cosmos EVM
Integration of the Ethereum Virtual Machine (EVM) as a module in Cosmos SDK chains. Enables Ethereum-style smart contracts and tooling (MetaMask, Hardhat, Remix) alongside native Cosmos features.

CosmWasm
A WebAssembly (Wasm)–based smart contract platform for Cosmos. Developers write contracts in Rust (or other languages that compile to Wasm) and deploy them on Cosmos chains that support CosmWasm.

CLI (Command Line Interface)
A terminal-based tool for interacting with blockchain nodes: sending transactions, querying state, and managing keys (e.g. WireFluid CLI, evmosd).

D

DAO (Decentralized Autonomous Organization)
An organization whose rules and treasury are encoded in smart contracts; governance is typically token-based voting.

DeFi (Decentralized Finance)
Financial applications (lending, trading, derivatives) built on blockchains without central intermediaries.

Delegator
In Cosmos PoS, a token holder who delegates tokens to a validator to earn staking rewards without running a node. Delegators share in rewards and in slashing risk.

Denom
Short for “denomination.” In Cosmos, the unit name of a token (e.g. uatom, uwire). The Bank module tracks balances by denom.

Deployment
The act of publishing a smart contract to the blockchain by sending a transaction that stores its bytecode and returns a contract address.

dApp (Decentralized Application)
An application that uses smart contracts and/or blockchain data. Users often connect via a wallet (e.g. MetaMask) to interact with the chain.

E

EIP (Ethereum Improvement Proposal)
A design document for changes or standards on Ethereum and EVM-compatible chains. Well-known examples include ERC-20 (EIP-20) and ERC-721.

EOA (Externally Owned Account)
On the EVM, an account controlled by a private key (e.g. a user wallet). EOAs can hold balance and send transactions; they are not contract code.

ERC-20
A standard interface for fungible tokens on EVM chains. Defines methods such as transfer, balanceOf, and approve.

ERC-721
A standard for non-fungible tokens (NFTs) on EVM chains. Each token is uniquely identified (e.g. by token ID).

Ethereum JSON-RPC
A remote procedure call (RPC) API used by Ethereum and EVM-compatible nodes. Wallets and tools (MetaMask, Hardhat, ethers.js) use it to read chain data and send transactions.

Event
A log entry emitted by a smart contract during execution. Indexed and stored in transaction receipts; used by frontends and indexers to react to on-chain actions.

EVM (Ethereum Virtual Machine)
The deterministic runtime that executes smart contract bytecode on Ethereum and EVM-compatible chains. Cosmos EVM runs this environment inside a Cosmos SDK module.

EVM-Compatible
A chain that implements the EVM and Ethereum JSON-RPC so that Ethereum contracts and tooling (wallets, Hardhat, Remix) work with minimal changes. WireFluid is EVM-compatible.

F

Faucet
A service that dispenses testnet (or sometimes mainnet) tokens for free. Used by developers to get tokens for gas and testing (e.g. WireFluid faucet).

Fork
A change to protocol rules that can create a divergent chain history. A hard fork is not backward compatible; a soft fork tightens rules while remaining compatible with old clients where possible.

Full Node
A node that stores and validates the full blockchain history. It can serve RPC and participate in the network without being a validator.

Fungible Token
A token where each unit is interchangeable (e.g. ETH, WIRE, ERC-20 tokens). Contrast with non-fungible tokens (NFTs).

G

Gas
A measure of computational work for executing a transaction or contract on the EVM. Each opcode consumes a fixed amount of gas.

Gas Fee
The cost paid to the network (in the native token) for processing a transaction. Typically gas used × gas price. On Cosmos EVM, the model aligns with Ethereum tooling.

Gas Limit
The maximum gas a user is willing to spend on a transaction. Prevents runaway execution and caps cost.

Gas Price
The price per unit of gas (e.g. in gwei). Together with gas used, it determines the total fee.

Genesis
The first block or initial state of a blockchain. Genesis configuration defines initial validators, balances, and chain parameters.

Governance Module
Cosmos SDK module that supports on-chain proposals and voting (e.g. parameter changes, software upgrades). Token holders or validators vote based on stake.

Gwei
A unit of ether: 1 gwei = 10⁻⁹ ETH. Often used to express gas price.

H

Hardware Wallet
A physical device that stores private keys and signs transactions offline. Examples: Ledger, Trezor. Used as a cold wallet.

HD Wallet (Hierarchical Deterministic Wallet)
A wallet that derives many keys from a single seed (mnemonic). The same seed restores the same keys on any compatible wallet.

Hot Wallet
A wallet whose private keys are stored on an internet-connected device (e.g. browser extension, mobile app). Convenient for frequent use but more exposed to attack.

I

IBC (Inter-Blockchain Communication Protocol)
A protocol for trust-minimized communication between Cosmos SDK chains. Enables transfer of tokens and arbitrary data across chains.

IBC Transfer
The act of sending tokens or data from one Cosmos chain to another using IBC. Relayers relay packets between chains.

Immutable
Data that cannot be changed after deployment. In Solidity, immutable and constant variables are set once and then read-only.

Injected Provider
A browser API (e.g. window.ethereum) provided by a wallet extension like MetaMask. dApps use it to request accounts and send transactions.

Interoperability
The ability of different blockchains to exchange data or assets. Cosmos emphasizes interoperability via IBC; bridges connect Cosmos to non-Cosmos chains (e.g. EVM).

K

Keystore
An encrypted file (often JSON) that stores a private key. Protected by a password. Used for backup and programmatic key management (e.g. in node scripts).

Key Derivation
The process of deriving child keys from a parent key or seed. HD wallets use standardized paths (e.g. BIP-44) so different apps derive the same addresses.

L

Ledger
The append-only record of all blocks (and thus transactions) on a blockchain. Replicated across full nodes.

Liquid Staking
Staking where the user receives a liquid (tradeable) representation of their stake, so they can earn rewards while retaining liquidity.

M

Mainnet
The production blockchain where real value and real economic activity occur. Contrast with testnet.

Mempool
A node’s pool of pending transactions not yet included in a block. Validators select from the mempool when building the next block.

Merkle Tree
A tree structure used to efficiently summarize and verify data (e.g. transaction list in a block). Block headers often store a Merkle root for the transactions.

MetaMask
A popular browser and mobile wallet for EVM and EVM-compatible chains. Used to hold keys, sign transactions, and connect dApps via an injected provider.

Module
In the Cosmos SDK, a reusable component that implements a set of functionality (e.g. bank, staking, governance, IBC). Chains compose modules to define their behavior.

Msg (Message)
In the Cosmos SDK, the payload of a transaction that triggers state changes in a module. A transaction can contain one or more messages.

msg.sender
In Solidity, a global variable that holds the address of the account (or contract) that called the current function. Used for access control and attribution.

Mnemonic (Seed Phrase)
A human-readable list of words (e.g. 12 or 24 words) that encodes a seed for key derivation. Anyone with the mnemonic can recreate the same keys; it must be kept secret and backed up securely.

N

Network
A distinct blockchain instance (e.g. WireFluid Testnet, Ethereum Mainnet). Identified by Chain ID and often by a name and RPC URL.

Node
Software that participates in the blockchain network: storing/validating blocks and, optionally, serving RPC. Types include full nodes, validators, and light clients.

Non-Fungible Token (NFT)
A token that represents a unique asset (e.g. ERC-721). Each token ID is distinct and not interchangeable with another.

O

Opcode
A low-level instruction executed by the EVM (e.g. ADD, SSTORE, CALL). Smart contract bytecode is a sequence of opcodes; each has a fixed gas cost.

Oracles
Systems that provide external data (e.g. price feeds) to smart contracts. Contracts cannot access the internet directly; oracles bridge off-chain data to on-chain use.

P

Packet
In IBC, a unit of data sent from one chain to another. Relayers relay packets according to IBC channel rules.

Private Key
A secret value used to sign transactions and prove ownership of an account. Must be kept confidential; loss means loss of access to the account.

Proof of Stake (PoS)
A consensus mechanism where validators are chosen and weighted by their staked tokens. Used by Cosmos chains and Ethereum (post-merge).

Public Key
Derived from a private key; can be shared. Used to derive the account address and to verify signatures.

Precompiles
Special contracts at fixed EVM addresses that implement native logic (e.g. cryptographic functions). On Cosmos EVM, precompiles can expose Cosmos SDK module features to Solidity contracts.

Provider (RPC Endpoint)
A URL (e.g. https://evm.wirefluid.com) that clients use to send JSON-RPC requests to a node. Wallets and dApps need a provider to read chain state and submit transactions.

R

Relayer
In IBC, software that watches two chains and relays packets (e.g. token transfer messages) between them. Relayers are off-chain and can be run by anyone.

Replay Attack
Reusing a signed transaction on another network or chain. Chain ID and other fields in the signature are used to bind the transaction to a single network and prevent replay.

RPC (Remote Procedure Call)
A way for a client to call functions on a remote node (e.g. get balance, send transaction). Ethereum and Cosmos expose RPC/API endpoints for this.

S

Seed Phrase
See Mnemonic.

Signing
Using a private key to produce a cryptographic signature over a message (e.g. a transaction). The network verifies the signature with the public key/address.

Slashing
A penalty in PoS systems where a validator (and sometimes its delegators) lose staked tokens for misbehavior (e.g. double-signing, prolonged downtime).

Smart Contract
Code deployed on a blockchain that runs when invoked by a transaction. It can hold state, transfer tokens, and call other contracts. On EVM chains, typically written in Solidity.

Solidity
A high-level programming language for writing EVM smart contracts. Compiles to EVM bytecode and is widely used on Ethereum and EVM-compatible chains.

Staking
Locking tokens to participate in securing the network (e.g. as a validator or delegator in Cosmos PoS). Stakers typically earn rewards and may be subject to slashing.

Staking Module
Cosmos SDK module that handles bonding, delegation, and validator set updates. It defines how tokens are staked and how rewards and slashing are applied.

State
The current data stored on the blockchain: account balances, contract storage, and module-specific data. Each new block updates state by applying transactions.

State Sync
A sync mode where a node obtains the latest state (e.g. a recent snapshot) instead of replaying all historical blocks. Speeds up node bootstrap.

T

Testnet
A public blockchain that mirrors mainnet behavior but uses valueless tokens. Used for development, testing, and demos (e.g. WireFluid Testnet).

Token
A digital asset on a blockchain. Can be the native gas token (e.g. WIRE, ETH) or a custom token (e.g. ERC-20, Cosmos denom).

Transaction (Tx)
A signed message that requests a state change: transferring tokens, calling a contract, or triggering module logic. Must be included in a block to take effect.

Transaction Receipt
Data returned after a transaction is executed: success/failure, gas used, contract address (for deployments), and logs (events).

U

User Interface (UI)
The part of an application that users see and interact with. In dApps, the UI often connects to the blockchain via a wallet and RPC.

V

Validator
In PoS, a node that proposes and votes on blocks and is rewarded (and possibly slashed) according to its stake. Cosmos chains have a limited validator set (e.g. top N by stake).

Validator Node
A full node that runs validator software and participates in consensus and block production.

Verification (Contract Verification)
Publishing source code and compiler settings to a block explorer so users can verify that deployed bytecode matches the claimed source. Improves transparency and security.

W

Wallet
Software or hardware that stores private keys and lets users view balances, sign transactions, and connect to dApps. Examples: MetaMask (hot), Ledger (cold).

Web3
The ecosystem of decentralized applications, smart contracts, and user-owned data and assets, often accessed via wallets and EVM-compatible RPC.

WebSocket
A protocol for persistent, two-way connection to a node. Used for subscribing to real-time events (e.g. new blocks, pending transactions). WireFluid exposes wss://ws.wirefluid.com for EVM subscriptions.

WIRE
The native token of the WireFluid network. Used for gas fees and, on mainnet, for value transfer and staking.

Z

Zero Knowledge (ZK)
A cryptographic method by which one party can prove that a statement is true without revealing the underlying data. Used in privacy and scaling solutions (e.g. ZK rollups).