Extrinsic

An extrinsic is a piece of information that originates from outside the blockchain and is included in a block. It represents a request for state change, such as a transfer of funds, a smart contract call, or a governance vote. Extrinsics are submitted by external actors like users or off-chain workers, in contrast to intrinsics, which are inherent, system-generated data within a block.

A typical extrinsic in a Substrate-based chain contains several key parts:

• Signature: Proves the origin and authenticity of the sender, paying the transaction fee.
• Call: The specific function to be dispatched (e.g., balances.transfer).
• Call Data: The arguments for the function call (e.g., recipient address and amount).
• Signed Extensions: Additional data for the runtime, such as a nonce for replay protection, a tip for priority, and the transaction's era for longevity.

An extrinsic follows a strict lifecycle:

1. Creation & Signing: A user constructs and signs the extrinsic with their private key.
2. Submission: It is broadcast to the network via a node's RPC endpoint.
3. Pool & Propagation: It enters the transaction pool (mempool) and is gossiped to other nodes.
4. Inclusion: A block author (e.g., validator) selects it for inclusion in a new block.
5. Execution & Finalization: The runtime executes the call, and upon block finality, the state change is permanent.

Extrinsics are categorized by their origin:

• Signed Extrinsics: Have a verifiable signature from a fee-paying account. They are used for standard user actions like transfers.
• Unsigned Extrinsics: Lack a signature and are not subject to regular fee payment. They are used for specific, validated operations like off-chain worker submissions or pre-signed transactions from a trusted source, requiring custom validation logic in the runtime.

Transaction fees for signed extrinsics are calculated by the runtime's fee model, typically: Fee = Base Fee + (Byte Fee * Length) + (Weight Fee * Complexity). A tip can be added to increase transaction priority in the pool. The weight system measures the computational resources a call consumes, ensuring fees reflect the cost to the network. Invalid or overly resource-intensive extrinsics are rejected.

Extrinsics are the interface to a blockchain's runtime logic. The Call enum in the runtime aggregates all possible transaction types from individual pallets (modules). When an extrinsic is processed, the runtime decodes the call and dispatches it to the corresponding pallet function. This modular design allows developers to define custom extrinsic types for their application-specific logic.

The most common extrinsic type, transferring native tokens from one account to another. This updates the Balances pallet's storage for both the sender and recipient.

• Core Function: balances.transfer_keep_alive or balances.transfer.
• Key Property: Requires the sender to have a sufficient existential deposit and pay a transaction fee.
• Example: Alice sends 10 DOT to Bob's account.

Extrinsics that interact with the Nominated Proof-of-Stake (NPoS) consensus mechanism. These manage the bond between nominators and validators.

• Common Calls: staking.bond, staking.nominate, staking.chill.
• Purpose: Secure the network by allocating stake, electing validators, and claiming rewards.
• State Change: Modifies storage in the Staking and Session pallets.

Extrinsics used to participate in on-chain governance, such as submitting referenda, voting, or enacting treasury spends.

• Mechanism: Interacts with the Democracy, Council, and Treasury pallets.
• Process: A proposal is submitted, enters a voting period, and, if passed, is queued for enactment.
• Example: treasury.propose_spend to request funds from the chain's treasury.

Extrinsics that deploy or call functions on a smart contract residing on a parachain like Astar or a smart contract chain.

• Deployment: contracts.instantiate with the contract's WASM code.
• Execution: contracts.call to invoke a specific function on a deployed contract.
• Fee Model: Uses a weight and gas system to meter and charge for computation.

Extrinsics that allow users to attach on-chain information to their account, such as a display name, social handles, or legal credentials.

• Pallet: Primarily the Identity pallet.
• Functions: identity.set_identity, identity.add_registrar.
• Use Case: Builds reputation and allows for human-readable addresses beyond the public key.

An extrinsic that is the result of a multi-signature approval process. It is dispatched from a multi-sig account after the required threshold of signatures is collected.

• Creation: First, a multisig.approve_as_multi call is made to collect signatures.
• Execution: Finally, multisig.as_multi is called to pay the fee and execute the wrapped call.
• Security: Enforces decentralized control over high-value accounts or protocol treasuries.

An extrinsic is a piece of information that comes from the outside world and is included in a block. It's the primary mechanism for users to interact with the chain.

• Analogy: Think of a blockchain as a shared database. An extrinsic is a user-submitted form (like a deposit slip or a transfer request) that the network's validators must process and record.

Extrinsics are categorized based on their origin and purpose:

• Inherents: Special extrinsics inserted by a block author (e.g., a validator) that contain information verifiable only at that moment, like a timestamp. They are not signed by users.
• Transactions: The most common type. Signed extrinsics that represent actions like token transfers or smart contract calls. They require a signature and pay a fee.
• Unsigned Transactions: Rare, for specific use cases where a signature is not possible or practical, requiring custom validation logic.

An extrinsic undergoes a strict validation process before state change:

1. Submission: A user constructs and signs an extrinsic, then broadcasts it to the network.
2. Pooling: The extrinsic enters the transaction pool (mempool), waiting to be selected by a block producer.
3. Inclusion: A validator includes it in a proposed block, executing its logic.
4. Execution & Finality: The runtime executes the extrinsic's logic, and upon block finalization, the resulting state change becomes permanent.

In Substrate-based chains (like Polkadot), an extrinsic has a standardized structure:

• Signature: (Optional) The cryptographic proof of the sender's identity.
• Call: The actual instruction, specifying the pallet (module) and function to call (e.g., balances.transfer).
• Extra Data: Contains the nonce (prevents replay), the tip (priority fee), and lifetime (transaction longevity).

It's critical to distinguish extrinsics from intrinsics:

• Extrinsic: External input. A request for state change (a transaction).
• Intrinsic: Internal state. The actual data stored on-chain (a block, an account balance, a smart contract's storage).

Extrinsics are the cause; the resulting changes to intrinsics are the effect.

An intrinsic is a state transition that occurs entirely within the blockchain's runtime logic, without an external signature. It is triggered by the system itself, not by a user.

• Examples: Block rewards for validators, slashing penalties, or automated smart contract executions from an oracle.
• Key Difference: Intrinsics modify state without a transaction fee, as they are part of the protocol's internal logic.

A transaction is the most common type of extrinsic, representing a signed piece of data that requests a state change from an external account.

• Components: Includes a signature, nonce, fee payment, and the call data specifying the action (e.g., token transfer).
• Lifecycle: Submitted to a node, validated, gossiped across the network, and included in a block by a block producer.

An inherent is a special type of unsigned extrinsic that contains authoritative data, like a timestamp, which is agreed upon by block validators rather than signed by a user.

• Purpose: Used for data that cannot be proven cryptographically but is accepted as true via consensus.
• Process: Validators insert inherents into blocks based on shared rules, and other nodes verify their validity.

A call is the core instruction within an extrinsic that specifies which runtime function to execute and with what parameters.

• Structure: Encodes the target pallet (module) and function (e.g., balances.transfer).
• Nesting: A single extrinsic can contain a batch of multiple calls or a call to a smart contract, which may trigger further internal calls.

A signature is the cryptographic proof attached to a transaction extrinsic, authorizing the state change and paying the associated fee.

• Function: Verifies the sender's identity and ensures the transaction has not been altered.
• Types: Common schemes include ECDSA (Ethereum), Ed25519, and SR25519 (Schnorr-based, used in Polkadot). Unsigned extrinsics, like inherents, lack this.

The block producer (or validator) is the network participant responsible for collecting extrinsics from a mempool, verifying them, and assembling them into a new block.

• Role: Selects which extrinsics to include, often based on fee priority. Ensures each extrinsic is valid (correct signature, nonce, fee).
• Output: The ordered list of executed extrinsics forms the block's body, and their resulting state changes are applied.