Overview

Tanssi is a decentralized infrastructure protocol that streamlines the launch of customizable appchains (application-specific blockchains) in minutes rather than months. It abstracts the heavy lifting—block production, security, data availability, and tooling—so builders can focus on business logic and user experience. Like “Kubernetes for blockchains”, Tanssi enables developers to deploy sovereign high-performance chains with full control over their network’s stack, minimal overhead, and fast time-to-market.

At the core of the design sits the Tanssi Network, acting as an onchain orchestrator that manages a global pool of resources such as decentralized sequencers. For each active appchain, the Tanssi Protocol takes care of sequencer selection and rotation, recording this work onchain. Sequencers are responsible for block production while a separate layer of Data Preservers runs full archive nodes to ensure Data Availability (DA) and expose RPC endpoints. Finality and economic security are delegated to external providers—initially Symbiotic on Ethereum—for block validation. This allows appchains on Tanssi to achieve Ethereum-grade security without bootstrapping their own validator set.

Developers can leverage a modular stack and ready-made templates, receiving bundled essentials—wallet integrations, block explorers, data indexers, bridges, oracles, crosschain messaging—out of the box. It’s this combination of pluggable architecture and pre-installed tolling that differentiates Tanssi from other competitors, collapsing time to market while ensuring application developers keep full design flexibility for their chains.

The native $TANSSI token powers the Tanssi Network coordination layer and captures value from the ecosystem of Tanssi-Powered Networks deployed on top. The token is used to register and operate appchains, pay sequencer and operator rewards, cover transaction fees, and govern protocol upgrades; holders may also delegate their stake to sequencers or operators for yield.

By abstracting infrastructure and importing external security, projects can launch Tanssi-Powered Networks to gain total runtime control and immediate, large-scale economic security while avoiding the overhead of bootstrapping a dedicated validator and tooling stack. With Tanssi, teams can spin up a chain in minutes instead of months, and channel their capital and energy into features and user growth instead of infrastructure overhead.

Problem Statement

Protocols increasingly insist on owning every layer of the stack, including their own chain, because that is the only way to guarantee performance, economics, and governance align with a single application’s needs while accruing value to their token. When a team has full control over block production it can customize fee logic, set block times to match UX targets, and remove noisy-neighbor unpredictable gas spikes, all without leaking value to underlying chain hosting their application. Builders, however, discover that launching an appchain still feels like running a L1 in addition to all the business logic involved in their application development and user onboarding processes.

Projects that need their own chain for scalability, compliance, or custom features, face steep hurdles and often resort to centralized shortcuts such as using Rollup-as-a-Service (RaaS) platforms that provide quick launches at the expense of sovereignty (centralized sequencing, vendor lock-in, etc). Others attempt fully sovereign chains but struggle with weak security (small validator pools, low economic stake) and operational burden.

Full-stack sovereignty drives the rising demand for appchains, yet building a new blockchain from scratch is historically complex, slow, and resource-intensive. Teams must spend months recruiting a decentralized validator set, configuring nodes, writing custom runtime code, and integrating essential infrastructure (RPC endpoints, crosschain messaging, find oracle providers, etc.). This lengthy deployment process often forces compromises in either speed or decentralization. The burden of infrastructure responsibilities teams have to incur is too high, not only for the initial deployment but also in terms of maintenance costs. To exemplify how operationally complex this is, consider how slow and capital-intensive the tasks below can be:

• Recruiting and coordinating a validator set is time-consuming, costly, and uncertain.

• Engineering bespoke infrastructure diverts focus and resources from the core product.

• Bootstrapping liquidity and onboarding users across isolated execution environments is detrimental for UX and fragments capital.

• Balancing performance vs flexibility is a key strategic decision with long-term impact; general-purpose L1s have throughput limitations and introduce fee volatility, while sovereign chains offer control at the expense of big engineering efforts and ongoing operations overhead.

These hurdles slow innovation, deter smaller teams, and leave demand for tailored, high‑throughput blockspace unmet. An ideal solution would drastically reduce launch time (from months to minutes), preserve decentralization (no central sequencers or upgrade authorities), and provide strong security from day one (comparable to leading L1s).

Tanssi turns the friction of blockchain deployment into an on-demand service layer that abstracts away the complexity and lengthy process involved in building and launching appchains. Protocols can leverage Tanssi’s developer-friendly and permissionless infrastructure to enter the market quickly and effortlessly, allowing teams to focus on product iteration, liquidity bootstrapping, and customer growth while Tanssi handles the technical heavy-lifting. As a result, the balance of power shifts toward developers and the community, away from middleware vendors or one-size-fits-all chains.

Value Proposition

The appchain thesis states that each application has an incentive to launch their own chain and have their native token accrue value capture instead of leaking it to an underlying host chain. As blockspace becomes cheap, modular, and commoditized, successful applications graduate from a shared “mall” (Ethereum, Solana, L2s, or any other general-purpose chain) to their own “storefront” with an application-specific chain they can own, control, and capture value from. Tanssi tackles the biggest blocker to that thesis: the cost-complexity tradeoffs of launching a new chain. When scale, performance, or economics demand it—and infra complexity is outsourced—apps rationally choose to become landlords instead of tenants.

Tanssi’s vision is to empower builders by eliminating the infrastructure barriers that hinder early-stage development and letting them focus on faster product iteration and customer growth. In other words, a world where developers focus more on innovation and less on technical overhead.

• Faster time-to-market: Launching a blockchain normally takes months of DevOps, validator recruitment, and tooling integration. With Tanssi it is a guided, self‑service flow that provisions everything in a few clicks, letting teams redeploy resources to product and go live faster.

• Ethereum-grade security: Restaked collateral in Symbiotic secures every Tanssi chain, letting projects inherit deep economic security without bootstrapping their own validator set.

• Full sovereignty: Each Tanssi-Powered appchain keeps its own runtime logic, tokenomics, and governance while still benefiting from shared security and crosschain connectivity.

• Modular runtime control: Tanssi lets builders start from an EVM-compatible template and add custom precompiles with forkless upgrades for continuous iteration.

• Turnkey data layer: Archive nodes guarantee Data Availability (DA) and expose RPC endpoints out-of-the-box.

• Native interoperability: A trustless two-way bridge allows for the seamless transfer of assets between Tanssi, Ethereum, and other ecosystems.

• Builder-rich toolkit: Pre-integrated oracles, bridges, indexers, block explorers, wallets, and other services shorten the path from prototype to production app.

Tanssi’s competitive edge lies in a holistic approach that combines the strengths of several paradigms: Substrate’s modularity for unlimited customization, shared security via restaking, chain sovereignty, and ease of deployment. Beyond deployment, Tanssi removes the need to run, secure, and monitor validator hardware, letting teams focus on application logic instead of infrastructure while accessing Ethereum-grade security from day one. Every Tanssi chain gets dedicated blockspace with its own sequencer set, and builders can choose their security mix depending on their application needs, or maturity stage.

• Appchain teams become network owners and their developers are in control of the chain’s custom runtime while getting a secure, scalable network without needing to invest in infrastructure engineering or recruit validators. They’re incentivized to drive real usage on their chain and Tanssi reduces the technical friction to do so.

• Sequencers and node operators run the Tanssi node software to provide block production services for appchains. They earn $TANSSI rewards in return as well as transaction fees from the appchains they serve.

• Restakers hold whitelisted assets like $ETH or $TANSSI. Token holders can delegate their stake to earn yield for securing Tanssi appchains.

• $TANSSI token holders retain governance rights and have an incentive to grow the Tanssi ecosystem. As more appchains launch, the demand for the token rises in line with its utility value. Token holders are incentivized through the value accrual of $TANSSI to make decisions that increase usage and security.

• End users of Tanssi appchains, while not direct participants in Tanssi, benefit from better performance and seamless UX.

Tanssi’s design ensures that convenience does not come at the cost of decentralization. It delivers blockchain-as-a-service without central trust and removes the need for teams to recruit their own validators or convince users to stake a new token. Unlike most Rollup-as-a-Service (RaaS) solutions that allow only limited configuration, Tanssi is built on Substrate’s modular framework. Teams can choose from EVM-compatible templates or craft custom Substrate modules for native runtime logic. All of this with a full stack of pre-integrated infrastructure that includes ready-made block explorers, indexing services, wallet integrations, oracles, and bridges from launch.

Offering a permissionless one-stop solution, Tanssi empowers developers by letting them launch their own chain with Ethereum-level security and the ability to retain full control and customizability. This transforms the appchain deployment experience from a risky bet and months-long sprint into a streamlined, trust-minimized process that effectively bridges the gap between fast deployment and true sovereignty. Teams can still upgrade the chain and perform runtime enhancements without forking the chain or causing any user disruption whatsoever.

Technical Architecture

At a high level, Tanssi’s architecture consists of four interconnected layers: Tanssi Network as the orchestration chain, Tanssi’s sequencer pool, Tanssi-Powered Networks, and a shared economic security layer.

Tanssi Network – Orchestration Chain	Substrate-based coordination chain that manages the registry of appchains and deals with staking and sequencer assignment requirements as well as with onchain governance and crosschain parameters
Tanssi’s Sequencer Pool	A shared pool of sequences that take care of block production for appchains. These operators opt in by staking $TANSSI and earn network rewards
Tansi-Powered Networks – Appchains	Independent blockchains with their own runtime logic and that retain sovereignty for fees configuration and tokenomics design
Shared Security via Restaking	The economic security layer for block validation, finality, and slashing

Built on Substrate, Tanssi supplies block-production-as-a-service and bundles the messy bits—sequencer set, staking module, explorers, wallets, RPC endpoints, oracles, and trustless bridging—so teams can focus on runtime logic inheriting Ethereum-grade security through Symbiotic restaking.

• Block Production as a Service: A decentralized pool of sequencers orchestrated by the Tanssi Network guarantees liveness and elasticity; operators do not need per-chain configuration and are actively shuffled and assigned to appchains.

• Shared Security: Restakers lock whitelisted assets in Symbiotic vaults for economic security. Approved operators validate Tanssi and all hosted chains; appchains inherit Ethereum-grade security, avoiding fragmented validator sets.

• Modular Framework: Developers can choose between templates (EVM, Substrate, custom) and hot-swap runtime pallets (components for functionality like staking, governance, etc.) without forking.

• Out-of-the-Box Tooling: Automated deployment of RPC endpoints, block explorers, data indexers, wallets, bridges, etc.

Developers launch appchains that plug into Tanssi’s shared sequencers pool, while Symbiotic node operators validate blocks and issue rewards. $TANSSI’s two-token architecture mirrors that flow: a native Substrate token for onchain fees and governance, and a 1:1 ERC-20 bridged copy for staking and paying cross-ecosystem incentives.

Tanssi’s modular infrastructure protocol fast-tracks appchain deployment times with a builder-centric platform that comes equipped with essential tools such as wallets, oracles, bridges, etc. All of this is provided out-of-the-box, removing both the technical hurdles and integration overhead that have historically hindered progress for launching appchains.

Orchestration and scalability are achieved as Tanssi avoids a shared consensus state between the Tanssi Network and Tanssi-Powered Networks. Each Tanssi-Powered Network is a sovereign appchain with its own dedicated block producers and chain state. These block producers are assigned on a per-chain basis, and the only shared component is the underlying security provided via staking. This allows each appchain to benefit from economic security without bootstrapping its own validator set while Tanssi can scale capacity linearly as more appchains are onboarded. Adding more chains only results in additional block producers, but transactional processing capacity is never compromised because of horizontal scaling.

Tanssi Network

Tanssi unlocks horizontal scaling with Kubernetes-style orchestration of appchain-specific containerized workloads. The Tanssi Network acts as the “orchestrator” chain assigning resources—sequencers, data preservers, RPC gateways—to each Tanssi-Powered Network, or appchain.

Built with Substrate’s client/runtime split: the core client handles networking, storage, and consensus gossip, while the Wasm runtime enforces all protocol logic and can be upgraded without forks.

Tanssi is the Substrate-based coordination chain that manages the registry of appchains, the staking and assignment of sequencers, crosschain messaging, and global governance parameters. It’s the backbone that keeps track of which sequencer nodes should be working on which appchain.

Substrate is a Software Development Kit (SDK) written in Rust and designed for building highly customizable chains. All onchain interactions are abstracted away from end users, who simply use their wallets to interact with dApps. Once transactions land on a node, the core client is responsible for responding to data requests or queuing transactions for execution in the runtime. While the default configuration of a Substrate node can be appropriate for most use cases, teams are still welcome to innovate by adding or replacing components. One notable characteristic, however, is that the runtime is compiled to WebAssembly (Wasm) byte code, which offers advantages such as:

• Portability: Wasm is platform-agnostic and the same binary code can be run on different nodes with different hardware architectures or operating systems.

• Deterministic Execution: the same input always produces the same output, which is critical in a blockchain environment to ensure that the network obtains the same state transitions across every node to reach consensus.

• Forkless Upgradeability: Since Substrate stores the Wasm blob onchain, the runtime itself becomes part of the state, which allows for seamless runtime logic upgrades that don’t require forking the chain.

• Modular Functionality: A Substrate runtime consists of different modules that define what transactions are exposed, the logic behind them, and how modules interact with each other.

Despite the separation of concerns within a Substrate node between the core client and the runtime, communication occurs through a well-defined interface that allows for necessary operations such as:

• Transaction Execution: users submit transactions to a client node, which passes this information to the runtime for execution.
• State Querying: client nodes can query the current state of the chain to retrieve information such as account balances, or specific data from smart contracts.
• Consensus and Finality: the runtime determines the validity of new blocks and ensures that consensus rules aren’t broken while the client node coordinates consensus and finality.
• Event Listening: events are emitted on the runtime during execution for client nodes to update users about state changes.

Acting as the orchestrator layer and control plane, the Tanssi Network keeps metadata for every active appchain, tracking their assigned sequencer, latest state root, and proof receipts. It also runs the sequencer selection algorithm each session and makes those results available for any party to verify. This allows appchains to launch with minimal DevOps effort and let their teams focus on application logic.

Sequencer Layer & Block-production-as-a-service

Appchains deployed with Tanssi have their blocks produced by Tanssi’s incentivized block producers, as Tanssi guarantees liveness and provides a decentralized set of sequencers. Scaling block producers capacity is a linear process as more appchains are added, since each new appchain requires their own set of sequencers.

A shared pool of independent sequencers offers block-production-as-a-service to any appchain launched through Tanssi. Upon assignment, Tanssi rotates sequencers on a per-session basis, shuffling the pool and re-assigning sequencers per network. In parallel, a native staking module ranks sequencers by self-stake + delegated stake, and delegators have the option to choose between manual or auto-compounding reward pools. Rewards accrue once Tanssi verifies that the expected sequencer authored a block that was finalized by the external security provider.

Appchains pay a series of fees to cover the sequencing costs associated with block production:

• Registration Deposit: initial deposit that is locked for network registration.

• Sequencer Assignment: fixed feed once per session that gives networks the right to be assigned sequencers.

• Block Production: networks pay for each block produced on their behalf.

Staking for Block Production

Inspired by LP-token accounting in AMMs, Tanssi’s staking module tracks non-transferable shares and funnels every delegator through four liquidity pools that map to the life-cycle of a stake: Joining, Manual-Rewards, Auto-Compound-Rewards, and Leaving.

Delegated tokens first enter the Joining Pool and stay there for at least one full session until the Joining Shares are burned in order to mint Manual-Rewards or Auto-Compound-Rewards depending on the user’s preferences (both mint new shares at a price fixed by the current token-to-share ratio).

• In the Manual-Rewards Pool delegators have to pull the accrued tokens from a protocol account by calling the unstaking function.
• In the Auto-Compound-Rewards Pool block rewards are automatically restaked every block. This increases the pool’s token balance while the share count stays constant and allows for the share price to rise and value to compound without user action.

Exiting requires a two-step undelegate flow. The intent moves the stake to the Leaving Pool, again imposing a full-session delay. After the delay, the protocol auto-claims any manual rewards, converts the original shares to tokens at the current pool’s price, and sweeps any dust into the Leaving Pool.

Shared Security Layer & Symbiotic Restaking

Tanssi relies on Symbiotic to supply a pool-based, Ethereum-grade shared security layer. Restakers deposit ETH (or other ERC20 tokens whitelisted as collateral, such as $TANSSI) into Symbiotic vaults. Onchain contracts track shares, handle delegation, and embed slashing logic. Vault managers then delegate the pooled stake to approved Symbiotic operators that also run Tanssi nodes.

In addition to maximizing the utility of staked assets and increase returns while improving network security, restaking prevents economic risks associated with other approaches where chains are forced to recruit validators, launch their own token, bootstrap liquidity, ensure the market cap is high enough for economic security, and make sure that this capital is sticky in the long term.

	Shared Security – Symbiotic Restaking	Stand-alone Validator Set
Security Source	Leverages ETH or other assets staked in vaults, giving every Tanssi appchain the same economic weight as Ethereum	Relies on the new chain’s native token; security is limited to what the team can attract and lock up (often modest at launch)
Capital Efficiency	Restakers earn dual yield on the same stake (native PoS + appchain rewards); no fresh capital is needed	Validators must stake fresh capital denominated in a newly launched token that powers the chain
Builder Upfront Costs	No need to fund or subsidize a validator set; you can tap into existing node operators staking for other networks	Must design incentives (inflation, grants) to convince validators, inflating supply or using treasury reserves
Bootstrapping Time	Security is inherited immediately after connecting to Symbiotic	Months to recruit, coordinate, and harden a credible validator set
Operational Complexity	Slashing, delegation, and accounting live in immutable Ethereum contracts; Tanssi just consumes finality signals	Team must write, audit, and maintain its own staking, slashing, and governance logic
Incentive Alignment	Restakers, operators, and every Tanssi appchain share the same collateral and slash risks, creating common incentives	Validators earn only this chain’s rewards; incentives siloed, reducing shared accountability
Early-Stage Viability	Suitable even for low-TVL apps; security is independent of the appchain’s own market cap	Early networks often overpay for unused capacity and still lack robust security, slowing product-market fit

Tanssi appchains prevent economic security death spirals by anchoring their security in Symbiotic’s restaking vaults rather than in appchain-specific tokens. Because economics and stake size never hinge on that token’s market cap, price drops don’t trigger validator exits or weaker finality. Appchains in Tanssi don’t need to recruit validators and can instead leverage Ethereum node operators that earn $ETH staking rewards plus their native token rewards.

Currently with Symbiotic, Tanssi-Powered Networks get economic security through permissionless Ethereum staking by delegating staked assets to operators. Vaults hold these assets as collateral while operators run nodes and resolvers arbitrate slashing. To prove the validity of blocks, Symbiotic operators sign receipts that are stored in Tanssi, allowing Tanssi chains to gain Ethereum-based economic security without bootstrapping their own from scratch (e.g. launching a token, ensuring a broad validator set, distributing the token and growing its market, recruiting a validator set, etc).

Dishonest or malicious behavior is deterred with slashing, which penalizes improper operations—double signing, downtime, or approving invalid state transitions—with automatic penalties that reduce the operator’s staked assets.

Interoperability Layer

Tanssi bakes interoperability into every appchain with Cross-Consensus Messaging (XCM). Messages are passed from chain to another as small scripts that the destination chain interprets. The system makes no assumptions about chains involved, never assumes a reply, guarantees ordered delivery, and is asynchronous.

To reach another chain, a message travels through two unidirectional channels. Channels from appchains to Tanssi are opened at onboarding while channels from appchain to appchain require a governance request. Once both sides agree, Tanssi activates the channel. Separate lanes are needed for opposite directions (e.g. from source to destination and vice-versa).

Tanssi-powered Networks & Execution Layer

Tanssi‑powered networks are sovereign, application‑specific blockchains that plug into Tanssi’s decentralized infrastructure instead of building everything from scratch. By connecting to Tanssi, a chain immediately receives block‑production, data‑retrievability, and economic security from an external provider such as Symbiotic on Ethereum, letting teams stand up a production‑grade network in minutes rather than months.

• Modular Network Templates: Substrate, EVM, or custom runtimes can be shipped.

• Forkless Upgrades & Extensibility: Thanks to Substrate, appchains can add modules for extensive functionality and execute upgrades without forking the chain.

• Sovereignty: Each appchain can decide its own fee model, tokenomics, and feature set; Tanssi only orchestrates block production while finality is achieved through economic security bootstrapped via Symbiotic staking.

Each network runs its own runtime atop a modular tech stack, yet offloads liveness and block production to Tanssi, which assigns sequencers to appchains for that purpose. This rotating set of sequencers orchestrated by Tanssi is responsible for handling block production, ensuring sovereignty without the chain needing its own dedicated validator set.

For builders, Tanssi ships open‑source templates that compress the learning curve. Both the Baseline template and the EVM template provide consensus, P2P, and security‑provider glue. The EVM template enables full Ethereum compatibility so developers can use Solidity for their smart contracts, while the Baseline template offers access to a Substrate runtime. Both templates are fully customizable to let teams focus on business logic and not waste time on boilerplate.

An appchain’s runtime defines the state transition rules between blocks. For that, Substrate provides many built-in modules called pallets that can be freely used as building blocks.

• Assets for dealing with fungible tokens

• Balances for accounting the appchain’s native token

• Democracy for voting

• Multisig for requiring multiple signatures to execute a transaction

• Recover for regaining access in the event of private key loss

• Staking for delegation and support rewarding and slashing

• Utility for contract multi-calls or delegate-calls

• Others for identity, vesting, etc

When users or apps submit transactions, these are validated at the full-node level using runtime-defined rules, and then they are queued in the transaction pool. A signed transaction is first validated for signature, nonce, weight, and fee, then placed in the ready pool. The valid transaction pool differentiates between two types: ready and future. The ready queue contains transactions that can be included in a new block while the future queue is for transactions that don’t meet all criteria to be included now but might become valid, like transactions with a future nonce.

Other features include:

• Pay-as-you-Go Block Production helps teams keep costs predictable and manage their onchain spend from block production, letting teams top up funds when they need it. Without sufficient funds, however, appchains are halted and cannot continue running. The Block Production Services Payment Dashboard provides a holistic view of balance, days remaining, cost per block, and cost per session.

• Token Management for Appchain Oversight allows teams to efficiently manage the gas token for their chain, giving teams full control over gas dynamics. This streamlines operations and ensures efficient resources management.

• Native Crosschain Communication allows appchains to communicate with each other, enabling them to share functionality and data.

• Built-in Chain Abstraction in collaboration with Particle Network’s Universal Accounts. This enables a single user account across multiple chains without switching wallets, bridging assets, or worrying about gas fees.

Tanssi removes the grind of spinning up a blockchain, and users can deploy straight from Tanssi’s dApp choosing a template so existing tools work out of the box.

Once deployed, Tanssi’s dApp and the developer portal help to further manage network resources for day-to-day operations such as:

• Check Service Payments: to top up balances for sequencing fees.
• Token management: for operations like minting, burning, or moving tokens.
• Monitor Network Overview: a dashboard that surfaces block height, RPC/WS endpoints, and basic health indicators about chain status

 

Tanssi ↔ Ethereum Bridge

The Tanssi ↔ Ethereum bridge removes the silos between the two ecosystems. It lets tokens and arbitrary messages move without a trusted custodian, so applications on either chain can treat the other as an extension of its own state. This is achieved coordinating a series of actors with different roles:

Role	Runs on	Responsibility
Prover	Tanssi BEEFY Pallet & Ethereum Beacon Chain	Export finalized consensus data
Relayer	Offchain	Pick up proofs from the source chain and post them to the destination chain. They are stateless and cannot forge messages
Verifier	Onchain light clients	Validate remote proofs before any action is taken
Gateway Contract	Ethereum	Single entry‑point that validates proofs and executes token unlocks or contract calls

This is achieved by coordinating two consensus paths: one on Tanssi’s BEEFY and one on Ethereum’s Beacon Chain.

• Tanssi → Ethereum: BEEFY signs a commitment to final Tanssi headers. A relayer submits the commitment and proof to Ethereum, where the BEEFY light client verifies signatures before the Gateway executes the payload.
• Ethereum → Tanssi: The Beacon Chain serves as a prover. A relayer submits a finalized header and proof; Tanssi’s Ethereum light-client pallet validates it before dispatching the message.

Because both chains re-verify every proof, relayers cannot fabricate messages, and multiple relayers can run in parallel for liveness without adding trust assumptions.

• End-to-end light-client verification removes reliance on multisigs or trusted committees.
• Stateless, permissionless relayers provide liveness without granting signing power.
• Economic alignment is achieved across networks: operator keys and staking live on Ethereum with Symbiotic, ,and Tanssi imports that snapshot to pick sequencers or request slashing through the same bridge.

Economic Design

Tanssi’s economics center around the fixed-supply $TANSSI utility token. Two 1-to-1 representations keep it portable: a native Substrate version that powers onchain voting, appchain registration, sequencer staking, and fee payment, and an ERC20 minted or burned via a trust-less lock-and-mint bridge so restakers on Ethereum can post collateral or claim rewards without custodial risk.

Every appchain must cover three main costs associated with Tanssi’s block-production-as-a-service:

• Registration Deposit: Initial deposit that is locked in a registration transaction.

• Sequencer Assignment: A fixed fee charged per session every time a sequencer is assigned.

• Block Production: Fee for each block produced.

Staking rewards for sequencers, operators, and token holders delegating their assets follow an inflation schedule that can be tuned via governance. Security is imported through Symbiotic restaking and the protocol returns $TANSSI rewards via Merkle proofs while slashing misbehavior by burning collateral.

• Operators stake $TANSSI to earn fees and $TANSSI rewards; if they deliver consistent uptime they attract more delegated stake capital. Since downtime or fraud slashes their stake, the rational play is to invest in resilient infrastructure.
• Restakers seek yield optimization and shift away from operators who underperform, which penalizes bad actors.
• $TANSSI ties the loop together with appchains: sequencer fees are paid in $TANSSI, and staking demand from operators, restakers, and governance voters increases the value and security of the ecosystem.

Each participant is economically incentivized to play their part faithfully: developers to build great apps and keep their chain funded, operators to keep chains running honestly, stakers to choose solid operators, and token holders/governors to foster growth while safeguarding security.

Participants & Incentives

Tanssi binds every actor and ecosystem participant through one cohesive token model with $TANSSI at the core of it. $TANSSI is the coordination lever for every role in the system and all service payments—appchain registration deposits, per-session sequencer assignment fees, per-block fee—are settled in $TANSSI. Sequencers earn those fees as block-production revenue, but they must first win a spot in the active set by posting stake.

Sequencers	Block Producers	Stake $TANSSI > produce blocks > earn block-production-fees plus an inflationary reward stream; failure or downtime triggers slashing
External Security Operators	Symbiotic Validators	Restake $TANSSI on Ethereum and accrue rewards
Delegators	Token Holders	Delegate $TANSSI to any sequencer pool and earn a proportional share of rewards without running hardware themselves
Data Preservers	Full Archive Nodes	Run full nodes that preserve and store history and expose RPC endpoints, earning TANSSI and potentially also appchain token rewards
Appchain Teams		Registration bond $TANSSI payment and pay-per-session assignment fee (100 × 10⁻⁶ $TANSSI per session) + micro-fee per block (1 × 10⁻⁶ per block)

Tanssi ranks sequencers by bonded stake, then shuffles and rotates them across networks each session, creating an economically weighted yet permissionless pool. To earn staking rewards, token holders don’t have to run hardware and they can delegate to sequencers or operators. Delegators bear no slashing risk, as the protocol aligns risk with the party that controls the key; the validators that restake via Symbiotic on Ethereum would face slashing if they submit invalid proofs.

$TANSSI

$TANSSI is the native token of the Tanssi permissionless infrastructure protocol for launching decentralized appchains, ensuring network functionality and security, and fueling ecosystem growth. Appchains pay for block production, sequencers and operators compete and get paid for honest work, stakers supply economic security in exchange for yield, and governance keeps the rules transparent and adjustable.

Staking & Security	Restakers, operators, and sequencers stake $TANSSI to secure Tanssi and Tanssi-Powered Networks
Service Payments	$TANSSI is required for appchain deployments, block production, and crosschain messaging
Operator & Sequencer Incentives	Operators and sequencers earn $TANSSI in return for their role in securing the ecosystem
Governance	Token holders participate with governance proposals and voting on initiatives such as treasury allocations, protocol upgrades, etc

Inflation mints $TANSSI into the rewards that flow to sequencers, operators, and $TANSSI stakers delegating to them; appchains pay for deployment and sequencer block fees; governance is managed by token holders for treasury decisions. This flow makes $TANSSI simultaneously a security incentive, a unit of account for its infrastructure services, and a governance right to guide future utility and value accrual mechanisms.

Community & Ecosystem	38.3%	30% unlocked at TGE & 70% 3-year monthly unlocks	Long-term support for ecosystem building and community rewards with initiatives such as contributor airdrops, liquidity incentives, and grants
Early Backers	24%	1-year cliff followed by 40% unlock & 60% 1-year monthly vesting	Investors who funded early development
Core Contributors	22%	1-year cliff followed by 30% unlock & 70% 2-year monthly vesting	Team and core contributors
Foundation Reserve	10%	30% unlocked at TGE & 70% 3-year monthly vesting	Reserve for long-term protocol development and operational costs
Community Sale (LFL)	2.3%	Fully unlocked 40 days post-TGE	Public token sale for community participants ahead of TGE
Community (LFD Campaigns)	2%	20% unlocked at TGE & 80% 60-day daily vesting	Early participants in incentivized testnets (Let’s Forkin’ Dance)
Strategic Round	1.4%	15% unlocked 40 days post-TGE; remaining tokens vest linearly over the following 11 months	Post-TGE initiatives: ecosystem expansion, targeted community engagement activities, and strengthening team capabilities

$TANSSI’s expected value rises when appchains launch and drive fee payments and registration locks that shrink supply. Growing security demand from operators and restakers adds buy-pressure, while visible ecosystem wins—like major projects migrating or hard-to-copy integrations—strengthen its moat. Because $TANSSI functions as chain fuel, staking collateral, and governance weight, usage growth directly translates into sustained, multifaceted demand.

• Network adoption: Each active appchain must continuously buy $TANSSI to pay fees, creating steady demand.

• Security demand: Attractive staking yields spur purchases from operators and restakers seeking rewards or governance sway.

• Ecosystem moat: High-profile migrations, partnerships, and unique features enabled by Tanssi and Substrate customization capabilities raise expected future cash flows tied to $TANSSI.

• Incentives programs: Broader holder base and distributed ownership that increases decentralization and deepens markets.

Governance is driven by token holders with an emphasis on onchain transparency and community control. While the Foundation can steer proposals, token-weighted voting decides the outcome. Tanssi employs a Substrate-based onchain governance system that allows $TANSSI holders to propose and vote on parameter changes, runtime upgrades, etc. In Substrate, successful governance votes can authorize a runtime code upgrade without a hard fork. Importantly, Tanssi appchains run their own independent governance, and Tanssi governance is only concerned with the shared infrastructure (sequencer scheduling, crosschain interfaces, tokenomics of $TANSSI, etc.). While Tanssi could change parameters that affect appchains in aggregate, such as the fee rate per block, it cannot alter an appchain’s state or code.

Funding & Investors

Moondance Labs, the company developing the Tanssi appchain infrastructure protocol, secured $3 million in Seed Funding in May 2023 led by Arrington Capital with participation including Borderless Capital, Fenbushi, Haskey Capital, D1 Ventures, Hypersphere, C2 Ventures, and Jsquare among others. A second Strategic Round in March 2024 co-led by SNZ Capital, KR1, and Scytale Digital secured $6 million to accelerate development with some funds like Arrington Capital, Hypersphere, and Borderless Capital doubling down alongside others like Blockchain Founders Fund and angel investors like Gavin Wood (co-founder of Ethereum and creator of Polkadot and Kusama). In 2025 the Tanssi Foundation raised $1M through a Community Sale and another $850k Strategic Round was secured on July 8 led by KR1 ahead of mainnet launch.

Team

Moondance Labs is the team behind Tanssi. Francisco Agosti is the founder of Tanssi and CEO of Moondance Labs. He previously played a key role in the development of Moonbeam’s ecosystem. Under his leadership, ex-Moonbeam operators export proven Substrate expertise, BD muscle, and community-building playbooks to make Tanssi the go-to-appchain launchpad. The engineering leadership includes Gorka Irazoqui Apecechea and the team also features experienced specialists in marketing and ecosystem growth such as Katherine Quilca Barcelli and Thiago Rüdiger.

Tanssi	Decentralized protocol and permissionless infrastructure to streamline the process of launching, managing, and scaling appchains
Moondance Labs	Primary company responsible for the development of Tanssi, with focus on protocol engineering and technical innovation
Tanssi Foundation	Key contributor to the growth of the Tanssi ecosystem, with focus on community building, incentives campaigns, and governance support

Risks & Safeguards

Tanssi relies on a layered design that separates execution from economic security. At the smart contract level, dangers arise from unintended bugs, upgrade errors, or misconfiguration that could drain collateral or bypass slashing rules. Block production for appchains is outsourced to a rotating pool of sequencers, and liveness risk grows when demand for slots outstrips supply, so Tanssi lets networks “tip” for priority; the highest bidders are guaranteed assignment when capacity is tight, preventing starvation while preserving a market-based queue. Crosschain messaging introduces its own failure surface if errors mistakenly expose infinite-minting bugs or exploits targeting the “honeypot” of bridge-locked assets backing a minted representation. For data integrity, every chain counts with a set of incentivized Data Preservers that run full archive nodes and RPC endpoints; this redundancy keeps historical state accessible even if a subset of providers drops offline.

Risk	Impact	Safeguard
Sequencer Cartel	Censorship	Veto + Slashing
Bridge Exploit	Token Theft	Light-client bridge + Multisig pause
Symbiotic Slash	Network Contagion	Vault isolation + capped restake ratios
Data-Preserver Outage	Data Read Failures	Redundant & Incentivized Preservers
Governance Capture	Malicious Upgrade	Token distribution + Timelock enactment

Consensus & Security Layer risk vectors are related to Symbiotic and would target smart contract bugs. All economic security is restaked in Symbiotic vaults on Ethereum, and any flaw would seek to drain that collateral or halt staking rewards. Misconfiguration could also slash honest operators or fail to slash malicious ones.

Bridging & Interoperability is a risk in the event of bugs that allow for freezing or stealing bridged assets, which would break $TANSSI’s two-token parity model as well as undermine trust in the ecosystem.

Protocol Software & Upgrades would be linked to runtime bugs, but Tanssi pallets (composable runtime components) are customizable and appchains can be upgraded in a forkless manner.

Governance Capture could arise in token-weighted onchain votes that can be cornered by insiders. This is prevented with predictable issuance and community initiatives that seek to avoid voting apathy and spread the token distribution as broad as possible.

Overall, Tanssi’s threat model concentrates on three fronts—sequencers and operator honesty, bridge correctness, and runtime hygiene—and counters each with explicit economic penalties, layered proof verification, and deterministic finality checks. While some edge cases could arise in “black swan” events, these safeguards and mitigation procedures narrow the blast radius and make residual risk measurable for both builders and investors.

FAQ

What exactly is an “appchain” and how is it different from a normal blockchain?

Appchains are blockchains dedicated to a particular application, as opposed to general-purpose chains like Ethereum or Solana. Instead of deploying a smart contract on a shared chain, projects can run their own blockchain (appchain) tailored to their specific needs, for example with custom transaction logic, governance rules, their own token economics, etc.

What’s the core pain point Tanssi solves?

Launching a blockchain is both expensive and time-consuming, with multiple hurdles at the infrastructure, operations, and technical level that drag development timelines to the scale of multiple months. Tanssi removes that friction by letting teams spin up appchains that inherit Ethereum-grade security and outsource block production to Tanssi while retaining sovereignty to customize their own runtime, set their own fee logic, and tokenomics.

How does Tanssi’s model cut time-to-market and costs?

Tanssi appchains inherit Ethereum-grade security via Symbiotic restaking, which avoids the effort involved in recruiting a validator set and the capital involved in bootstrapping economic security from scratch. Substrate templates and premade modules allow teams to customize their runtime while still being able to go live in a matter of minutes or days instead of months. That chain instantly inherits block production, data availability, RPC endpoints, dedicated sequencers, and critical tooling (wallets, block explorers, oracles, bridges, etc) out of the box.

How is Tanssi different from launching an Ethereum L2 with a Rollup-as-a-Service (RaaS) provider? 

While both approaches can create a customized execution environment, there are some fundamental differences attributed to architecture choices. L2s batch transactions and post batches onto Ethereum, but even though that approach inherits Ethereum’s security, the design typically relies on a single centralized sequencer ordering transactions and still paying $ETH gas costs for settlement. Tanssi appchains are independent L1s that, instead of posting all data to Ethereum, inherit Ethereum’s security via Symbiotic staking while benefiting from Tanssi’s block-production-as-a-service. This approach allows for sovereignty and customizability with Ethereum-grade security.

How does Tanssi and Symbiotic ensure appchains achieve Ethereum-grade economic security? 

Through restaking, Symbiotic allows Ethereum’s stakers to opt-in to “restake” $ETH and other whitelisted assets into vaults that secure other networks. That staked $ETH (and other assets) forms a large pool of collateral and Symbiotic will assign some of those stakers (operators) to validate Tanssi appchains. Because those operators have economic value at stake that can be slashed, they are economically motivated to act honestly. In essence, Ethereum’s economic security (the cost to attack Ethereum) backs the appchain. Practically, Tanssi’s orchestrator is linked to an Ethereum smart contract (Symbiotic) that monitors validator performance and enforces slashing or rewards. This is done via a bridge with proofs and receipts of block finalization.

What’s the role of the $TANSSI token? 

$TANSSI is the protocol’s native asset. Holding it confers onchain voting power, and the token is required to pay for appchains deployment and ongoing fees. $TANSSI secures block production through staking on sequencers and operators, and serves as the reward currency for nodes.

How does Tanssi ensure that Tanssi-deployed appchains get Ethereum-grade economic security from day one without running their own validator set? 

Tanssi plugs into Symbiotic, an Ethereum restaking layer, as a shared security provider. Operators restake $ETH and other collateral assets in Symbiotic, and that economic weight is relayed to Tanssi appchains, which piggy-back on the same economic security backing Ethereum.

How much can builders customize the chain runtime? 

Tanssi is built on Substrate. Developers can leverage any existing template or create their own as well as tweak transaction types or extend EVM precompiles. The framework’s modularity lets teams add features in hours instead of rewriting a monolith, since all of this is achieved without touching consensus or networking code.

How can teams do forkless runtime upgrades without disrupting users? 

An appchain runtime lives onchain as a Wasm blob. Governance would schedule a new blob, sequencers reference it, and from that block forward every node validates identical code with zero downtime.

How are sequencers, operators, and token holders paid? 

Sequencers earn block-production rewards in $TANSSI and share a portion with delegating stakers. Operators (validators in Symbiotic) receive separate rewards that are also shared with delegators. Token holders can stake in sequencers or staking operators to earn yield with no slashing risk.

Why does $TANSSI exist in both Substrate and ERC20 form? 

Native $TANSSI handles staking, fees, and governance on Tanssi; the ERC20 mirrors supply on Ethereum for restaking payouts and external liquidity. A trustless bridge keeps the two representations 1-to-1, letting capital flow where it is most useful.

Links

Website: Tanssi Network

Docs: docs.Tanssi Network

Apps: apps.Tanssi Network

X: @TanssiNetwork

LinkedIn: Tanssi Network

Telegram: @TanssiOfficial

Discord: Tanssi Server

Youtube: Tanssi Network

Github: Tanssi Repo