What Is NEAR Token? Chain Signatures Explained

Last updated: 2025

What Is NEAR Protocol?

NEAR Protocol is a proof-of-stake Layer 1 blockchain designed for scalability and developer accessibility. Built with a sharding architecture called Nightshade, the NEAR blockchain processes transactions at high throughput and low cost, and it serves as the foundation for Chain Signatures, its native cross-chain signing capability. NEAR is developed and maintained by the NEAR Foundation, a nonprofit organization focused on fostering the NEAR ecosystem.

NEAR uses a proof-of-stake consensus mechanism, where validators stake NEAR tokens to participate in block production and earn rewards. This validator network is the same infrastructure that powers Chain Signatures, a detail that becomes significant when you understand how the signing process works.

Nightshade, NEAR's sharding model, splits the network's transaction processing across parallel shards, allowing throughput to scale without sacrificing security. Unlike older Layer 1 architectures that process transactions sequentially, Nightshade lets NEAR handle more activity as the network grows.

The NEAR token is the native currency of the NEAR network, used to pay transaction fees, fund smart contract execution, and stake in consensus. Every Chain Signatures interaction on NEAR consumes NEAR tokens for gas, so protocol usage has a direct economic relationship with the token.

What makes NEAR genuinely distinctive today is a feature called Chain Signatures, which enables NEAR smart contracts to interact directly with Bitcoin, Ethereum, and other supported blockchains.

What Makes NEAR Different From Other Layer 1 Blockchains?

Three architectural choices set NEAR apart from other Layer 1 blockchains: human-readable account names, a sharding model built for throughput, and Chain Signatures, the feature that makes NEAR's omni-chain vision possible.

NEAR accounts use human-readable identifiers like alice.near rather than hexadecimal addresses. This design choice matters beyond usability. Chain Signatures derives addresses on foreign blockchains deterministically from a NEAR account ID, so a single alice.near identity can control a Bitcoin address and an Ethereum address without separate wallets.

NEAR's account model and Chain Signatures are part of a broader move toward account abstraction, a design pattern that decouples user identity from the underlying signing infrastructure, making blockchain interaction more flexible. (Developers coming from Ethereum can also use Aurora, an EVM-compatible environment built on NEAR that supports Solidity contracts.)

NEAR calls its broader direction the omni-chain vision: a world where a single application built on NEAR can read and write to any blockchain, using NEAR as the coordination layer. Chain Signatures is the technical mechanism that makes that vision buildable today.

The Problem Chain Signatures Solves: Why Blockchain Interoperability Is Hard

Blockchains are isolated networks by design. A Bitcoin node has no knowledge of Ethereum, and an Ethereum smart contract cannot natively read Bitcoin's state or authorize a Bitcoin transaction. This isolation is fundamental to each chain's security model. But it creates a genuine problem: blockchain interoperability, the ability to move value or data between independent chains, has historically required trusted intermediaries.

The two dominant workarounds have been cross-chain bridges and wrapped assets. Bridges lock assets on a source chain and mint token representations on the target chain. Wrapped Bitcoin (wBTC), for example, is an Ethereum token backed one-to-one by real BTC held in custody. Both approaches introduce counterparty risk. Bridges depend on the security of their smart contracts or custodians, and major exploits (Ronin, Wormhole, Nomad among them) resulted in billions of dollars lost. Ethereum does not currently have a native, chain-agnostic signing capability that avoids these intermediaries.

Bridges are not inherently bad; they serve real purposes and many operate reliably. The limitation is that they introduce trust and risk that not every use case can afford.

NEAR Chain Signatures approaches this problem differently: not by building another bridge, but by enabling NEAR smart contracts to generate valid cryptographic signatures for transactions on any chain, interacting with Bitcoin and Ethereum exactly as those networks exist today.

What Are NEAR Chain Signatures?

A cryptographic signature is the mathematical proof, generated using a private key, that authorizes a blockchain transaction. Every time you send cryptocurrency, your wallet produces one. Without a valid signature, a transaction is rejected by the network.

NEAR Chain Signatures is a feature of NEAR Protocol that allows NEAR smart contracts to sign transactions on any blockchain, including Bitcoin, Ethereum, and EVM-compatible networks, without requiring a bridge, wrapped asset, or external custodian. It uses a cryptographic technique called Multi-Party Computation (MPC) to generate these signatures securely.

NEAR Protocol Chain Signatures represents a fundamentally different approach to cross-chain interaction. Rather than locking assets and minting proxies, a NEAR smart contract produces a signature that is valid on the target chain's own network. The result is cross-chain without a bridge: the transaction executes on Bitcoin or Ethereum directly, with no intermediary in the signing path.

To understand how this works, it helps to first understand the cryptographic technique powering it: Multi-Party Computation.

How Do NEAR Chain Signatures Work?

NEAR Chain Signatures achieves cross-chain transactions through a cryptographic technique called Multi-Party Computation. The sections below trace the process from foundational concept to complete signing flow.

What Is Multi-Party Computation (MPC)?

Multi-party computation (MPC) is a cryptographic technique that allows multiple independent parties to jointly perform a computation, such as generating a signature, without any single party ever seeing the complete private key.

Think of it like a bank vault that requires multiple keyholders to open simultaneously. No single person holds all the keys, and no single person can access the vault alone. MPC applies this principle to cryptography: the computation is split across participants, and the result, a valid signature, is produced collectively without any one participant ever possessing the full key.

(MPC is not a new concept. It already powers institutional custody products like Fireblocks and ZenGo, protecting billions in assets for financial institutions.)

NEAR MPC uses this technology to distribute signing authority for foreign-chain addresses across its validator network, enabling the system to produce signatures for Bitcoin, Ethereum, and other chains without any central key holder.

Threshold Signatures: How the Key Is Never Whole

The specific MPC protocol Chain Signatures uses is called a Threshold Signature Scheme (TSS). In TSS, a private key is never assembled in one place. Instead, key fragments are distributed across NEAR's validator nodes, the same node operators who process NEAR transactions and have economic stake in the network's integrity. A minimum number of these validators, the "threshold," must cooperate to produce a valid signature, but no single validator ever holds the complete key.

A concrete example: if the threshold is 2-of-3, any two of the three key-share holders can cooperate to produce a valid signature, but neither can act alone, and the full key is never reconstructed.

This differs from standard multi-signature schemes common on blockchains like Bitcoin. In multisig, all co-signers' signatures appear on-chain and are visible to anyone reading the transaction. In threshold signing, the cooperation between validators produces a single standard signature, indistinguishable from one generated by a single private key. The target chain sees a normal transaction.

The Chain Signatures Signing Flow

The complete process for producing a cross-chain signature works as follows:

1. A developer deploys a NEAR smart contract (written in Rust or JavaScript/TypeScript) that calls the Chain Signatures signing contract.
2. The signing contract sends a request to NEAR's MPC network, specifying the target blockchain and the transaction payload.
3. A threshold of NEAR validators cooperate via the Threshold Signature Scheme to produce a cryptographic signature valid for the target chain, without any single validator holding the complete key.
4. The signature is returned to the calling contract, which broadcasts it to the target blockchain to execute the transaction.

Each NEAR account can be used to derive a corresponding address on any supported blockchain. If your account is alice.near, Chain Signatures can derive a deterministic Bitcoin address and an Ethereum address from it, meaning your single NEAR identity controls accounts on multiple chains without needing separate wallets for each. This is how NEAR achieves cross-chain transactions without a bridge or custodian at any step.

NEAR Chain Signatures vs. Cross-Chain Bridges: What's the Difference?

Cross-chain bridges work by locking assets on one chain and minting representations on another. NEAR Chain Signatures works differently, and the differences matter for both security and user experience.

The wrapped asset comparison deserves concrete illustration. Today, accessing Bitcoin's value inside an Ethereum DeFi protocol requires converting BTC into wrapped Bitcoin (wBTC), an Ethereum token backed by real BTC held in custody by a third party. This introduces counterparty risk, conversion fees, and ongoing custodian dependency. Chain Signatures offers a different path: a NEAR smart contract can control a real Bitcoin address directly, signing Bitcoin transactions natively without any wrapping. (The same pattern applies to other wrapped asset forms, such as renBTC or cbBTC.)

Two other interoperability approaches are worth brief comparison. Polkadot's relay chain and parachain architecture enables cross-chain communication, but it requires participating chains to adopt Polkadot's protocol. Bitcoin and Ethereum are not Polkadot parachains, so NEAR Chain Signatures requires no changes to the target chain whatsoever. Cosmos IBC (Inter-Blockchain Communication) similarly requires participating chains to implement the IBC protocol. NEAR Chain Signatures can interact with Bitcoin and Ethereum exactly as those chains exist today, with no protocol modification on their end.

Bridges serve real and important roles in today's ecosystem, and many operate reliably. The comparison above is meant to clarify the architectural differences, not to dismiss bridge-based approaches.

Is NEAR Chain Signatures Secure?

Yes. NEAR Chain Signatures is designed with a security model that prevents any single party from unilaterally controlling the signing keys.

No single entity controls the complete private key for any Chain Signatures-derived address. Key fragments are distributed across NEAR's validator network, the same validators who process NEAR transactions and have real economic stake in the network's integrity through their staked tokens. The private key for a foreign-chain address is never assembled in one place. It is used jointly by a threshold of validators only at the moment of signing, and even then no single validator sees the full key.

To compromise a Chain Signatures-controlled address, an attacker would need to simultaneously compromise a supermajority of NEAR's validator set. That bar is materially higher than exploiting a single bridge smart contract, where a vulnerability in one contract can drain all locked assets. The underlying MPC technology is not experimental; it has been used in institutional custody products for years, protecting billions in assets for organizations that cannot afford single points of failure.

NEAR Protocol's mainnet has been live since 2020 and is maintained by the NEAR Foundation. For current audit status of Chain Signatures specifically, refer to the NEAR Foundation's official security documentation and the NEAR GitHub repository, which carry the most accurate and up-to-date verification details.

No cryptographic system carries absolute guarantees, and Chain Signatures is no exception. What the threshold signing model provides is a distributed trust assumption: security rests on the honest majority of a large, economically incentivized validator set, rather than on the integrity of a single custodian or smart contract.

What Can You Build with NEAR Chain Signatures? Use Cases Explained

A dApp (decentralized application) is software that runs on a blockchain rather than a centralized server, executing via smart contracts. NEAR Chain Signatures significantly expands what dApps can do across every supported network.

NEAR Chain Signatures Use Cases

Here are the most concrete applications available to builders today:

• Omni-chain DeFi protocols. Build a lending or trading protocol on NEAR that sources liquidity from Bitcoin and Ethereum simultaneously, without deploying separate contracts on each chain. DeFi (decentralized lending, trading, and yield protocols) has historically been confined to single-chain ecosystems; Chain Signatures removes that constraint.
• Bitcoin-native dApps without wBTC. Create applications that interact directly with Bitcoin mainnet, signing BTC transactions from NEAR smart contracts with no wrapped Bitcoin and no custodian.
• Cross-chain NFT platforms. Issue NFTs on NEAR and have Chain Signatures authorize transfers or interactions on Ethereum or other EVM chains from a single NEAR contract.
• Multi-chain portfolio management. Build wallets or portfolio tools that control assets across Bitcoin, Ethereum, and NEAR from a single NEAR account identity.
• Cross-chain DAOs. Create governance systems where NEAR-based votes trigger on-chain actions on Ethereum or other supported networks.
• Chain-agnostic identity systems. Enable users to authenticate once on NEAR and interact with any supported blockchain without managing multiple separate wallets.

Yes, NEAR can interact with Bitcoin natively via Chain Signatures. Here is exactly how that works in practice.

Example: Signing a Bitcoin Transaction from NEAR

This is the scenario that distinguishes Chain Signatures from every bridge-based alternative:

1. A developer's NEAR smart contract calls the Chain Signatures signing contract with a Bitcoin transaction payload, including the recipient address, the amount, and any other required fields.
2. The MPC network produces a valid ECDSA signature, the specific cryptographic proof that the Bitcoin network requires to authorize any transaction, without any single validator holding the complete signing key.
3. The signature is broadcast to the Bitcoin network. The transaction executes natively on Bitcoin mainnet, with no bridge, no wBTC, and no custodian involved.

To sign a Bitcoin transaction from a NEAR smart contract, the developer does not deploy anything on Bitcoin, does not wrap any asset, and does not rely on a third-party custodian. The NEAR contract calls Chain Signatures; the Bitcoin network sees a valid, standard Bitcoin transaction.

Ethereum and EVM Chain Support

Yes, Chain Signatures supports Ethereum and all EVM-compatible chains. A NEAR smart contract can authorize Ethereum transfers, call Ethereum DeFi protocols, or execute any EVM transaction. A user interacting with a NEAR-based application could engage with an Ethereum lending protocol without ever needing a separate Ethereum wallet.

Who Is Building with NEAR Chain Signatures?

Chain Signatures is in active development, with builders across DeFi, gaming, and infrastructure verticals beginning to adopt it. The NEAR Foundation ecosystem directory tracks projects building on NEAR, including early adopters of Chain Signatures. Rather than cite unverified project names or adoption figures here, the ecosystem directory is the right place for current, accurate information on who is building and what they are shipping.

The NEAR Foundation actively supports builders through grants, developer resources, and dedicated documentation. Adoption is growing as the infrastructure matures.

Why NEAR Chain Signatures Matter: The Omni-Chain Vision

Chain Signatures is not just a technical feature. It is the foundation of NEAR's omni-chain vision: a future where a single application can interact with any blockchain, and users need only one account to access all of crypto.

Today, a developer building a cross-chain application must choose which chains to support, deploy separate smart contracts on each, maintain multiple codebases, and depend on bridges to move value between them. Chain Signatures changes that architecture: one NEAR contract, one account identity, and access to any supported chain.

This direction aligns with a growing movement in blockchain development called account abstraction, the design pattern that decouples user identity from the signing infrastructure so that applications manage cross-chain complexity rather than passing it to users. NEAR's approach is part of a larger architecture the project calls Chain Abstraction, where the end goal is that users interact with applications without needing to know which underlying blockchain is running.

The significance here is architectural, not promotional. If signing authority over any chain's transactions can be held in a NEAR smart contract, then NEAR becomes a coordination layer for a multi-chain world, not a replacement for Bitcoin or Ethereum, but a programmable interface to both.

Frequently Asked Questions About NEAR Chain Signatures

What is NEAR Chain Signatures?

NEAR Chain Signatures is a feature of NEAR Protocol that allows NEAR smart contracts to sign transactions on any blockchain, including Bitcoin, Ethereum, and EVM-compatible networks, without a bridge, wrapped asset, or custodian. It uses Multi-Party Computation (MPC) to generate cryptographic signatures for external chains securely and without a central key holder.

How does NEAR Chain Signatures work?

Chain Signatures works through a Threshold Signature Scheme built on MPC. A developer calls a NEAR smart contract, which requests a signature from NEAR's validator network. A threshold of validators cooperate to produce a valid cryptographic signature for the target chain, with key fragments distributed so no single validator holds the complete key. The signature is then broadcast to the target chain, executing the transaction natively.

Can NEAR interact with Bitcoin natively?

Yes. NEAR can interact with Bitcoin natively through Chain Signatures. A NEAR smart contract can produce a valid ECDSA signature for a Bitcoin transaction, which is then broadcast to the Bitcoin network and executes on Bitcoin mainnet directly. No bridge, no wrapped Bitcoin (wBTC), and no custodian is involved at any step.

Can NEAR sign Ethereum transactions?

Yes. Chain Signatures supports signing transactions on Ethereum and all EVM-compatible chains. A NEAR smart contract can authorize Ethereum token transfers, call Ethereum smart contract functions, or interact with any EVM DeFi protocol. Users do not need a separate Ethereum wallet to interact with Ethereum through a NEAR-based application that uses Chain Signatures.

Is NEAR Chain Signatures secure?

Yes. NEAR Chain Signatures uses a distributed security model where no single party controls the complete signing key. Key fragments are held by NEAR's validator nodes, and a threshold of validators must cooperate to produce any signature. Compromising a Chain Signatures-controlled address would require simultaneously compromising a supermajority of NEAR's validator set, a significantly higher bar than exploiting a single bridge contract.

Who controls the keys in NEAR Chain Signatures?

No single entity controls the keys. Private key material is split into fragments distributed across NEAR's validator network. The complete private key is never assembled in one place. Validators cooperate to produce a signature only at the moment it is needed, and even then no individual validator sees the full key. The security model relies on the honest majority of an economically incentivized validator set.

What is MPC in blockchain?

Multi-party computation (MPC) is a cryptographic technique that lets multiple independent parties jointly perform a computation, like generating a signature, without any single party seeing the complete private key or intermediate values. Think of it like a vault that requires multiple keyholders to open simultaneously: no single person can act alone, and no single person ever holds all the keys.

Get Started with NEAR Chain Signatures

If you're ready to build with NEAR Chain Signatures, here's what you'll need to get started: a NEAR account, familiarity with NEAR smart contract development (contracts are written in Rust or JavaScript/TypeScript, not Solidity), and an understanding of the transaction format for your target chain, whether Bitcoin, Ethereum, or another supported network.

The official NEAR Chain Signatures documentation at docs.near.org is the authoritative starting point. It covers the signing contract interface, key derivation paths, and the request format for each supported chain. Tutorials and quickstart guides are available there; this article is a conceptual explainer, and the documentation is where implementation begins.

Developers starting from scratch with NEAR can find language guides, SDK references, and testnet resources at the NEAR developer portal. For investors and researchers tracking ecosystem adoption, the NEAR Foundation ecosystem directory is the right place to follow which projects are building with Chain Signatures.

(Ethereum developers who want EVM compatibility on NEAR can also explore Aurora, NEAR's EVM-compatible environment, which supports Solidity contracts on NEAR's execution layer, separate from Chain Signatures.)

Chain Signatures opens the door to building applications that span every blockchain. The infrastructure is ready, and the documentation is waiting.

Related Reading

• What Is Cardano (ADA)? Crypto Blockchain Explained
• What Is Polkadot? Crypto, DOT Coin, and Parachains Explained