Overview

NFTs are pretty cool, but how can we make them smarter? I’ve recently been assigned the task of implementing an on-chain solution for attaching intelligent metadata to new or existing NFTs and SFTs on The Root Network. This solution is a small piece of a larger puzzle that will allow AI and Blockchain tech to coincide, using each other’s strengths and helping us move one step closer to a truly open and intelligent metaverse.

What makes a token intelligent?

Intelligence itself is a term used relatively loosely. I hope we can come to an agreement that the human race is intelligent and even stretch to including any living thing. Anyone who’s ever owned a dog will relentlessly swear by their intelligence, but where is the line drawn? Before the rise of AI this may have been an easier question to answer, but recently the definition of intelligence is far from what it was even 5 years ago. Alan Turing used human intelligence as the baseline, stating that any machine capable of obscuring its digital soul from a human judge is thereafter considered intelligent. This test seemed impossible to beat in 1950, however less than a century later the field of AI has progressed far beyond what was ever conceivable. AI today is far more than just a convincing conversationalist, but a concept artist, a personal composer, a peer programmer and much much more. Congratulations AI, as humans we can confidently say that you are without a doubt intelligent.

OK hear me out, I can already sense your loud thoughts questioning the relevance of this article, especially when written by a blockchain developer like myself. I mean aren’t AI and Blockchain two completely separate fields?

Although AI and Blockchain are definitely two very different beasts, there are far more overlapping regions than you may initially think. At Futureverse we aim to explore these areas, envisioning a digital world powered by decentralized ownership and intelligent automation. We’re building tools and experiences for the open metaverse, not just for a tech-curious gamer, but for an entire planet of curious minds and intelligent individuals. Part of this goal is to provide limitless capability to an existing set of digital assets we know as NFTs. These Non-Fungible Tokens have proven to the world that they are valuable, and have already stirred up more interest and controversy than most modern day pop stars, but their time is not over. By bringing the power of an almost human equivalent AI brain to these characters, we can see two massive worlds collide, producing splendid outcomes in an ever expanding digital landscape.

Merging AI and Blockchain

Sounds easy right? All we have to do is take the pre-existing NFTs on The Root Network, slap on some intelligence that would have made Alan Turing proud, and call it a day!  Although I wouldn’t choose the word easy to describe this task, the role of the chain itself is only a small part of the big picture. The unfathomable complexity of our AI models is not suitable for 100% on-chain representation, it’s simply not what a blockchain is designed to do. We need to somehow design a system that allows any end user application to retrieve the intelligent data associated with a specific NFT (represented by a token ID) and apply its different aspects within their game or experience. For the keen eyed amongst you, this may seem eerily familiar, as it shares a lot of similarities with the pre-existing metadata system.

For some background, when building protocol level systems, every Byte is valuable. The end user is charged for each nano-second of processing power their transactions take to execute so efficiency is key. This means that storing Gigabytes of data per token is not feasible. For this reason, the actual NFT data such as images, videos, 3D models, and other relevant fields are stored behind a link to a third party API such as IPFS or other data hosting platform. That way the only data we need to store on-chain is the url for the data and not the data itself.

This is the same for on-chain intelligence, each individual NFI agent contains the following fields:

• Genome Matrix: Static data that represents the initial state, or DNA of an AI agent, its fundamental behaviour and attributes stem from this matrix.
• Emotional Palette and Skills Matrix: A personality and attribute profiling index for each individual agent, derived from their unique genome mapping. These provide each agent with consistent behaviours and interaction patterns, a key component of multi-app interoperability and continuity.
• Murmur Matrix Card: The Murmur Matrix is a mutable data layer used to store contextual information about an intelligent asset. This includes recording its interaction data and in-world experiences, often referred to as memories.

The Murmur Matrix, Emotional Palette and Skills Matrix are mutable and evolve over the tokens lifetime, so this part will be stored entirely off-chain. The Genome Matrix however still ends up being around 2KB per token when heavily compressed. For a collection of 10,000 tokens that would be 2MB which is almost the size of the Runtime itself! Not to mention the added performance cost of compressing and decompressing the data each time we access it. We can’t realistically store all of this on chain, so we need to provide a link for each tokens data, easily retrievable by any third party that wishes to take advantage of it. Pushing the intelligence metadata off-chain also makes it far easier for the AI model to grow and change as it learns to adapt to each new app it gets used in.

Sounds simple enough right? Although one thing to consider is the fact that this data is now contained within some third party outside of our chains strict and verified ledger, we need some way to validate that this data is what we say it is. That’s where the verification hash comes into play. The goal of the added verification_hash field is to provide a sha256 hash of the static contents of the data behind the metadata link, this hash is immutable so if at any point the data stored within the link is changed, it will no longer be verified and therefore considered invalid.

pub struct NFIMatrix {
  // Link to metadata stored on external servers
	pub metadata_link: BoundedVec<u8, MaxDataLength>,
	// Hash to verify integrity of metadata content
	pub verification_hash: H256,
}

Please Welcome, Pallet NFI

We know what we need to do and roughly how to do it, but what’s the correct way to implement this new piece of work into The Root Network? Adding intelligence to an NFT sounds like it’s very closely tied to the NFT Pallet, so attaching this extra logic in there would almost make sense, but we want to include intelligence for SFTs as well. If you read my article on the Marketplace Pallet you will know that we prefer to keep the role of a pallet fairly concise and organised, separating logic out wherever it makes sense. That’s why we decided to encapsulate all of the new logic into a new pallet, pallet_nfi.

This pallet will store all of the metadata links, allow collection owners to make their collections NFI enabled and manage and charge the added intelligence fees, redistributing a percentage back to the network through the Vortex. We can then link to this pallet from both the NFT and SFT pallets whenever a new token is minted, check whether the collection is NFI compatible and if it is, charge the fee and create the intelligence metadata.

Beauty! Now we’re done right? We have our shiny new NFI Pallet linked up to our Runtime, ready to receive requests when a token’s minted. The pallet also charges the fees with redistribution so we can finally call it a day! But wait, we’re missing one crucial step, the actual metadata generation. I mentioned earlier that metadata was far too big to be stored on chain, but this goes for the generation as well. It’s not easy to create a Genome, so we need some off-chain service that can pick up requests from the chain, generate the intelligence metadata and then notify the chain about where that metadata is stored.

Enlisting some off-chain assistance

We’ll call this service the Relayer, its job is to listen to the NFI Pallet for any events requesting some new intelligent metadata to be generated for a token. When it picks up on an event (after a token is minted) it will then generate the Genome Matrix and Angle Matrix which are the key components required to create an AI brain that can learn and have unique attributes. After the Relayer stores this information somewhere, it’ll provide a URL link to that data, alongside a hash of the static contents, back to the NFI pallet by calling the submit_nfi_data extrinsic. The NFI Pallet verifies that the caller is our trusted relayer and will store the mapping between token_id and intelligence data safely in its pallet store.

Multi-chain Token Support

So far this solution is working great for tokens on The Root Network, but we don’t discriminate here, what if we want to allow for NFI data to be stored for tokens across any chain? This way we would greatly remove the barrier for entry of games or experiences that have new or pre-existing collections across multiple chains, without requiring them to bridge them over to The Root Network. This can be achieved relatively easily, however not every chain represents tokens the same which adds to the complexity. Let’s look at tokens on The Root Network. Collections and serial numbers are represented by an unsigned 32-bit integer, so you’d have something like this:

// The Root Network Token ID
TokenId {
	CollectionId: 1124,
	SerialNumber: 12
}

But now let’s look at Ethereum, where instead of collection IDs, tokens are grouped by contract addresses, which is the address for the ERC721 Smart Contract containing the logic for those tokens. Serial numbers can also be 256-bit unsigned integers. This would look like:

// Ethereum Token ID
TokenId {
	CollectionAddress: 0xccc441ac31f02cd96c153db6fd5fe0a2f4e6a68d,
	TokenId: 12 // u256
}

These are the two most common types, but what about tokens on chains like Avalanche, Sui, Arbitrum and chains that don’t even exist yet? Is it possible to represent tokens on all of these chains with one data structure?

Although it may be impossible to create a type that supports every future chain, we can take a guess at the data types and support all existing types with a data structure that allows for flexibility of both the collection and token identifiers. The chain_id is included as well to easily distinguish which chain the token belongs to.

/// Token Id that can support many types of collection_id and serial_number
pub struct MultiChainTokenId<MaxByteLength: Get<u32>> {
	pub chain_id: u64,
	pub collection_id: GenericCollectionId<MaxByteLength>,
	pub serial_number: GenericSerialNumber<MaxByteLength>,
}

/// Collection ID type that supports multiple chains
pub enum GenericCollectionId<MaxByteLength: Get<u32>> {
	U32(u32),
	U64(u64),
	U128(u128),
	U256(U256),
	H160(H160),
	H256(H256),
	Bytes(BoundedVec<u8, MaxByteLength>),
	Empty,
}

/// Serial Number type that supports multiple chains
pub enum GenericSerialNumber<MaxByteLength: Get<u32>> {
	U32(u32),
	U64(u64),
	U128(u128),
	U256(U256),
	Bytes(BoundedVec<u8, MaxByteLength>),
}

Handling Edge Cases

While this pallet’s systems contain relatively simple logic, there are always edge cases that need to be addressed. Picture this, you create an NFT collection and your initial mint run sees 5,000 lucky people buy into your project. You decide later that you would like to leverage the new NFI Pallet and introduce AI components to your planned experience. You head over to our new friend the NFI Pallet and enable NFI for your collection, but what happens to those 5000 tokens that already exist? Do they live on the chain as dumb tokens with no intelligent metadata? Does the collection owner pay for each one to have their metadata generated? Or does our relayer swallow the cost and just generate them without charging anyone?

None of these solutions are ideal, but we still want to allow NFI to be enabled on existing collections. The best solution, and the one we went with, is adding a manual step, callable by the token owner that allows them to request for NFI metadata to be generated on their existing token. All other NFI metadata is handled by an automated process on mint, but by allowing the user to fill in the gaps we can bring intelligence onto all NFT or SFT collections contained within The Root Network.

As with most things, this approach does come with a minor trade-off. We can no longer guarantee that a collection with NFI enabled has the required metadata generated for every token within the collection. A small price to pay sure, but this does mean that any services using the new pallet will need to check for metadata existence and handle the case where the metadata doesn’t exist.

Designing for the Future

So what now? We’ve provided the tools for tokens to become intelligent by attaching an evolving AI brain to them. We’ve created a new pallet where we keep track of all the intelligent metadata, and we’ve enlisted the help of a relayer to perform some heavy off-chain tasks. But how can we ensure this NFI Pallet stands the test of time? Currently the scope of this pallet encapsulates only one set of intelligent metadata for the core use case of NFI enabled agents, but down the line there may be room for more sets of metadata, equally important but separate by nature. We need to ensure our pallet has support for these future use cases to prevent any massive refactors and storage migrations in the future.

To accommodate for this potential use case, we abstracted the NFI metadata into the NFI category, with room for any other additional data that may need to be attached in a similar way in the future. This data categorisation is what we call the NFISubType.

pub enum NFISubType {
	NFI,
	FuturePlans,
}

pub enum NFIDataType {
	NFI(NFIMatrix),
	Future(FutureData),
}

As you can see by the above snippet, we separate out the NFI matrix data into the arm of an enum, that way we can easily categorise the data as NFI, and in the future have the freedom to add more types of intelligent metadata simply by adding extra enum variants. Although it may appear to be an over complication at this point in time where we only have one variant, I’m hoping future Jason will thank me for this one.

What’s next for Pallet NFI?

The NFI Pallet is designed to be used as a core identity component of the Think Agent Standard, known as the Soul. As an evolution of the ASM protocol, Think endeavours to create an open protocol that can keep up with the emergent needs of a quickly evolving agentic internet. The previous section talked about planning for the unknown, but are there any future improvements that we know a bit more about? This work is designed to be the foundation for intelligent support on The Root Network, and although I’m not about to drop a fat chunk of alpha at the end of this dev diary, I can speak a little on what our plans are. I’ve already mentioned that the relayer can be improved upon in its design so eventually that system will be fleshed out and made more decentralized to satisfy the philosophy of what we’re building. The dev experience for people wishing to utilize this technology is also very early days so a lot of our future efforts will be on streamlining this process. These efforts could involve creating an NFI SDK for users to mint tokens with NFI data on The Root Network and potentially any other chain.

But for now our brand new NFI Pallet is serving its purpose nicely and our chain is leading the charge with decentralized, AI compatible Non Fungible Tokens.

Learn about more features and custom pallets The Root Network has to offer here. To stay up-to-date with developments and join our growing community, follow us on X and join our Discord.

The Root Network is excited to announce the integration of Sequence, the leading open-source development platform powering blockchain ecosystems, games, and apps. This partnership strengthens our shared vision of an open metaverse that prioritizes user onboarding, interoperability, and cutting-edge blockchain solutions, making it easier than ever for builders and users to embrace web3 technologies.

What is Sequence?

Sequence is an open-source web3 stack that accelerates blockchain development.  Its end-to-end toolkit empowers game developers to onboard, monetize, and retain players effortlessly. With support for web, Unity, Unreal Engine, and mobile platforms, Sequence’s technology streamlines blockchain complexities, allowing developers to focus on creating engaging player experiences. Trusted by industry leaders like Take-Two Interactive, Ubisoft, and Coinbase, Sequence powers millions of users and is used by thousands of developers worldwide.

Sequence integrates seamlessly into game environments with features like non-custodial wallets, sponsored gas fees, and batched transactions. Its marketplace solutions and Smart Swaps optimize in-game economies, enabling players to trade, purchase, and monetize digital assets smoothly.

A Game-Changing Integration

Sequence has completed integration with The Root Network, giving developers easy access to our blockchain’s unique technology for the next generation of immersive and open gaming experiences. Sequence removes friction for developers and players with intuitive, plug-and-play blockchain tools, while The Root Network provides the infrastructure for interoperable, truly ownable digital content. Together, they create a powerful foundation for developers.

“The Root Network has built a powerful ecosystem of IP, and our partnership is the next step in TRN bringing world-class technology accelerate content and great experiences. Sequence powers unified accounts, seamless interoperability, and the kinds of games and apps that will make this metaverse thrive." Sam Barberie, Head of Strategy and Partnerships at Sequence.

Seamless Onboarding & User Experience

Sequence simplifies the player onboarding process through seamless wallet integrations, non-custodial functionality, and account abstraction. Players can easily interact with NFTs and in-game tokens without needing prior blockchain knowledge. Additionally, developers can sponsor gas fees and batch transactions, ensuring smooth gameplay while optimizing resource use across web, Unity, Unreal Engine, and mobile platforms.

Developers can also mint NFT collections directly within their games and integrate marketplace solutions that ensure compliance with app store policies. Smart Swaps tackle liquidity challenges, enabling players to use credit or debit cards to make purchases across various chains, unlocking new revenue opportunities. Sequence’s advanced analytics offer developers valuable insights into player behavior, helping them fine-tune gameplay and enhance engagement.

Interoperability Across Games & Chains

Sequence developers can now tap into The Root Network’s metaverse protocols for content interoperability, allowing game assets, NFTs, and digital identities to flow seamlessly between different experiences and ecosystems. This unlocks new opportunities for cross-game collaboration, asset portability, and broader audience reach.

AI-Powered Intelligent Assets

Through The Root Network’s NFI (Non-Fungible Intelligence) Pallet and the Think Agent Standard, Sequence builders can bring assets to life with AI. These intelligent agents carry contextual memory, spatial awareness, and interactive capabilities across multiple games and environments, revolutionizing how users engage with digital content in the metaverse.

“We are incredibly excited about our partnership with Sequence. By integrating their powerful web3 development platform, we are creating new opportunities for developers and players alike. Together, we aim to build an open, connected metaverse where seamless user experiences are the standards” Aaron McDonald, Co-founder and CEO at Futureverse.

Join us in building the next generation of open metaverse gaming with Sequence on The Root Network. Stay tuned for upcoming incentives and opportunities designed to accelerate innovation and adoption within our ecosystem.

For more details on Sequence and their web3 stack capabilities, visit Sequence.xyz.

Overview

In blockchain ecosystems, transaction fees are typically paid in the network's native currency. For The Root Network (TRN), this means users need XRP to pay for transaction fees. However, this requirement can create friction for users who hold other tokens but lack the native currency for gas payments. To address this challenge, we've implemented the Fee Proxy pallet, which enables users to pay transaction fees using any token - given that it has sufficient liquidity against XRP in TRN's on-chain Decentralized Exchange (DEX).

Understanding Fee Proxy

The Fee Proxy pallet is a critical infrastructure component that intercepts transaction fee payments and enables dynamic token conversion for gas fees. This means users can execute transactions on TRN using any token in their wallet, as long as there's adequate liquidity for that token against XRP in the on-chain AMM.

Key Features

1. Flexible Fee Payment: Users can pay transaction fees in any token with XRP liquidity
2. Automatic Token Conversion: Seamless conversion of chosen payment token to XRP for gas fees
3. DEX/AMM Integration: Utilizes TRN's on-chain AMM for efficient token swaps; this is a natural price oracle since arbitragers are incentivised to balance the price/value of the token(s)
   1. Additional utilization of the AMM - which further incentivises liquidity from liquidity providers
4. EVM Compatibility: Supports both substrate extrinsics and EVM transactions

How It Works

In traditional blockchains, users must hold the native currency (like ETH for Ethereum) to pay for transaction fees. However, TRN implements a novel gas abstraction mechanism that allows users to pay transaction fees using any token that has sufficient liquidity against the native currency (XRP).

The Role of the DEX in Fee Abstraction

At the heart of this mechanism lies our Uniswap V2-based Automated Market Maker (AMM) implemented as a Substrate pallet. The AMM serves two crucial functions:

• It provides real-time price discovery for tokens through liquidity pools
• It enables the actual swap of user's chosen payment token to the native currency

When a user initiates a transaction using a non-native token for fees, the system leverages the AMM's constant product formula (x * y = k) to determine the exact amount of the chosen token needed to cover the gas costs.The price discovery occurs automatically through the existing liquidity pools (specifically of the token and XRP), ensuring that fees are priced fairly according to current market conditions.

Price Discovery and Market Equilibrium

The accuracy and reliability of our gas abstraction system heavily depend on maintaining correct price discovery in the AMM pools.

This is achieved through a combination of market forces and arbitrage opportunities:

Arbitrage Mechanisms

When the price of a token in our AMM pools deviates from external market prices, arbitrage opportunities emerge.

Trading bots and arbitrageurs are incentivized to:

• Buy tokens from our pools when prices are lower than external markets
• Sell tokens to our pools when prices are higher than external markets

This constant arbitrage activity helps maintain price alignment with broader market rates, ensuring that users paying gas fees in alternative tokens are charged fair market rates.

Dynamic Pool Rebalancing

The AMM's constant product formula naturally creates price movements as pool ratios change:

• Large token swaps for gas payments can temporarily impact pool ratios
  • This creates immediate arbitrage opportunities
• Arbitrageurs quickly restore the balance by taking opposing positions
• The resulting equilibrium reflects the true market price

For example, if many users pay gas fees using TOKEN-A, gradually depleting the TOKEN-A supply in the pool:

• The pool ratio shifts, making TOKEN-A more expensive in terms of XRP
• Arbitrageurs notice the price discrepancy
• They buy XRP from external markets and trade it for TOKEN-A in our pools
  • This action replenishes the TOKEN-A supply and stabilizes prices

Economic Incentives

The system's stability is reinforced by several economic incentives:

• Arbitrageurs earn profits by correcting price discrepancies
• Liquidity providers earn fees from all swaps, including gas payment conversions
• Users are protected by specifying max_payment limits on their transactions

This creates a self-sustaining ecosystem where market participants are naturally incentivized to maintain accurate price discovery, ensuring the gas abstraction mechanism remains reliable and cost-effective for users.

Integration with The Root Network

The Fee Proxy pallet implements the OnChargeTransaction trait, which is the core mechanism for handling transaction fee payments on Substrate-based chain.The Fee Proxy pallet is deeply integrated with TRN's infrastructure:

Transaction Payment Configuration

impl pallet_transaction_payment::Config for Runtime {
    type OnChargeTransaction = FeeProxy;
// ... other configuration parameters
}

EVM Configuration

impl pallet_evm::Config for Runtime {
    type Runner = FeePreferencesRunner<Self, Self, Futurepass>;
    type OnChargeTransaction = FutureverseEVMCurrencyAdapter<Self::Currency, TxFeePot>;
// ... other configuration parameters
}

The trait implementations (FeeProxy and FeePreferencesRunner) highlighted above allow the FeeProxy components to hook into relevant pallets which deal with withdrawal of funds/XRP for a transaction. The fee proxy itself integrates with the Dex pallet to perform the swap.

The flexibility and ergonomics of substrate allow us to achieve all these integrations in a clean way.

Substrate Layer Implementation

Fee proxy pallet

The pallet handles fee calculation and token conversion through several key steps.When a user initiates a transaction with fee preferences, the following process occurs:

1. Gas Estimation: Calculate required gas based on transaction parameters
   1. The user specifies their preferred payment token and maximum payment amount
2. XRP Fee Calculation: Convert gas requirements to XRP amount
   1. The pallet calculates the required XRP amount for gas fees
3. Token Amount Calculation: Determine required payment token amount based on AMM rates
   1. The specified payment token is swapped for XRP through the AMM internally within the on-chain protocol code
4. Swap Execution: Perform the token swap through the AMM
5. Fee Payment: Use converted XRP for transaction execution
   1. The underlying transaction is executed using the converted XRP for gas fees

The entry point to executing a fee-proxy transaction is the following extrinsic in the FeeProxy pallet:

// Execute a transfer while paying fees in a custom token
fee_proxy.call_with_fee_preferences(
    origin,
    payment_asset_id,// The token to pay fees with
    max_payment,// Maximum amount willing to pay with token
    Box::new(transfer_call)// The actual transaction to execute
)

The fee abstraction is implemented through a specialized extrinsic called fee_proxy.call_with_fee_preferences.

This proxy acts as a wrapper around the actual transaction, handling the token conversion process transparently.

How it works:

• The user specifies their preferred payment token (payment_asset_id) and the maximum amount they're willing to pay (max_payment).
• Before executing the main transaction, the system queries the AMM to calculate the required amount of payment token based on:
  • The estimated gas cost in native currency (XRP)
  • The current exchange rate from the liquidity pool
• The system performs an atomic swap through the DEX pallet, converting the user's token to XRP
• The actual transaction (transfer_call) is executed using the swapped XRP for gas fees
• Any unused tokens are refunded back to the user

This mechanism ensures that while the blockchain continues to use XRP for actual gas payments internally, users enjoy the flexibility of paying with their token of choice, as long as there's sufficient liquidity in the corresponding AMM pool.

Flow

EVM Layer Integration

The Fee Proxy functionality is also accessible through an EVM precompile, allowing smart contracts and EVM transactions to utilize the same flexible fee payment system. The precompile interface is straightforward:

interface FeeProxy {
    function callWithFeePreferences(
        address asset,// Token address to pay fees with
        address target,// Target contract address
        bytes calldata// Encoded function call data
    ) external;
}

When using the EVM interface, the gas parameters (gasLimit, maxFeePerGas, and maxPriorityFeePerGas) determine the maximum gas cost in XRP, which is then converted to the equivalent amount in the chosen payment token based on current AMM rates.

The caller is responsible for performing the calculations (required gas/XRP) - which can be done via the estimateGas RPC call, then converting this to amount of tokens required (and ensuring that they possess the required amount).

Flow

Caveats to the EVM integration

Integrating the fee-proxy with the EVM proved to be a bit more difficult than anticipated. This is due to the fact that Ethereum based transaction flows take a different route in the code compared to Substrate extrinsics; resulting in slightly different implementations of the fee-proxy for the 2 different transaction flows.

The major difference however was the usage of the fee-proxy with frontend/browser wallets. Before allowing a user to execute a transaction; wallets (such as MetaMask) make an Eth RPC call to first simulate the transaction; but in this process, the transaction validation can fail due to the user having a 0 XRP balance. This is a state which should be accounted for; i.e. the user should still be able to execute a transaction while having no XRP, if they have another token to pay gas with.

^ To address this behaviour, we needed to make a change in frontier (our EVM implementation); essentially allowing custom logic (providing a trait) for the transaction validation.

The implementation for this trait is in the runtime:

pub struct HandleTxValidation<E: From<InvalidEvmTransactionError>>(PhantomData<E>);

impl<E: From<InvalidEvmTransactionError>> fp_evm::HandleTxValidation<E> for HandleTxValidation<E> {
	fn with_balance_for(
		evm_config: &CheckEvmTransaction<E>,
		who: &fp_evm::Account,
	) -> Result<(), E> {
		let decoded_override_destination = H160::from_low_u64_be(FEE_PROXY_ADDRESS);
		// If we are not overriding with a fee preference, proceed with calculating a fee
		if evm_config.transaction.to != Some(decoded_override_destination) {
			// call default trait function instead
			<() as fp_evm::HandleTxValidation<E>>::with_balance_for(evm_config, who)?
		}
		Ok(())
	}
}

Here we essentially check the target address of the the transaction, and if it is targeted towards the fee-proxy precompile address, then we simply allow the balance validation to go through.

With this change we have made frontier pallet transaction handling logic more flexible, while providing our own custom override for transaction validation.

Use Cases and Benefits

1. Enhanced User Experience
   • Users can transact without holding XRP
   • Seamless fee payment in preferred tokens
   • Reduced friction for new users
2. DApp Integration
   • DApps can incentivise and potentially subsidise gas fees for their users by via providing liquidity for their tokens against XRP
     • Eases usecases for gas sponsorships; for example any app can setup a liquidity pool with its token and XRP; then allow users to pre-buy (or buy at a discount) these tokens - which could be used for transaction fee payment
   • Simplified onboarding for new users as they could potentially interact with dapps even though they may not have the native currency at hand
   • Better UX for multi-token applications
3. Additional utility to all assets
   • Since any token can be used to pay for transactions; this essentially gives native utility to all tokens to be used as gas tokens
4. Cross-Chain Interactions
   • Easier integration with other chains and bridges
   • Simplified token management for cross-chain applications

‍

Future Improvements

Several potential enhancements could further improve the Fee Proxy system:

1. Gas Token Aggregation
   • Support for multi-hop swaps through multiple AMM pools
   • Optimal routing for better rates
2. Fee Abstraction
   • Account abstraction integration for more flexible fee payment models
   • Support for meta-transactions
3. Advanced Fee Strategies
   • Dynamic fee token selection based on market conditions
   • Batch transaction optimization

Conclusion

The Fee Proxy pallet represents a significant step forward in improving blockchain accessibility by removing the requirement for users to hold native tokens for gas fees. By leveraging TRN's on-chain AMM and implementing robust safety measures, the pallet provides a secure and efficient solution for flexible fee payment.

This innovation not only enhances user experience but also opens up new possibilities for DApp developers and cross-chain applications. As The Root Network continues to evolve, the Fee Proxy pallet will play a crucial role in fostering broader adoption and usability of blockchain technology.

‍

To learn more about The Root Network's features and custom pallets, visit our documentation. Stay updated with our latest developments by following us on X and joining our Discord community.

As we step into 2025, The Root Network and its ecosystem are powering up for a bigger year than ever. With over 60 projects rooted in open gaming and more on the way, The Root Network is steadily evolving, scaling, and pushing the boundaries of interoperability. As the year progresses, the pace of transformation is set to accelerate even further, with a focus on inter-chain connectivity, decentralization, and new initiatives designed to drive community and network growth.

Here’s a look at what’s coming:

Key Initiatives Roadmap

• Rewards Program
  • Dynamic rewards program that incentivizes users and builders across the The Root Network ecosystem, ensuring contributions to the network such as liquidity and transactions are both recognized and rewarded.

• Pass Attribution
  • A novel protocol that creates rewards for the lifetime value of users that partners and brands onboard onto The Root Network, and drive monthly active wallets (MAWs).

• Vortex Payouts On-Chain
  • Transition The Vortex payout distribution to a full automated and decentralized process.

• Substrate Upgrade
  • Upgrade to Substrate framework version Stable2409-1 (or newer). This enhancement will bring improved scalability, security, and performance to the ecosystem.
• Gas Fee Optimization
  • Ongoing enhancements to further optimize EVM transaction costs to bring them closer in line with extrinsic transaction expenses.
• IBC Protocol
  • Inter-Blockchain Communication (IBC) Protocol to enable cross-chain interoperability. This development will serve as an intermediate step to the future implementation of parachains, enabling seamless interactions between blockchains.
• Decentralized Governance
  • Decentralization takes center stage with the introduction of a decentralized governance model. This framework will empower the community to play a more active role in shaping the future of The Root Network.

TRN Labs Launches

As The Root Network’s builder and developer communities gear up for an exciting 12 months of growth, games, and opportunities, we have another significant update to reveal. Today, we’re thrilled to share the launch of TRN Labs, an independently-organized initiative dedicated to driving innovation, fostering collaboration, and maximizing The Root Network ecosystem’s potential. Led by builders, TRN Labs is aiming to drive builder and community initiatives in collaboration with Futureverse, with the objective of scaling the The Root Network’s ecosystem.

Key Initiatives

TRN Labs aims to identify new projects and provide resources to foster community growth. Whether a project is just starting out or aiming to scale, TRN Labs offers a variety of initiatives including Project Incubation, Technical and Infrastructure Support, Community Engagement, Sustainable Growth Models, and Expanding Network Connectivity.

Follow TRN Labs on X to stay up to date with the latest news and updates.

‍

In the year ahead, The Root Network will continue leading the development of seamlessly connected games, content, and experiences. Thanks to key infrastructure updates, innovative new features, and fresh opportunities for builders and developers, the future of the network and its ecosystem has never been so bright. We look forward to growing and building together in 2025.

A brand new wallet that combines the ease of social login with robust non-custodial security has just launched on The Root Network. Available for iOS and Android devices, the Girin Wallet is designed to make digital asset management easier across The Root Network and XRPL.

The concept for the wallet was born when the Girin Labs team recognized the need for a simple, secure, and accessible wallet that could onboard $XRP’s 50 million holders and introduce them to the magic of The Root Network – empowering users with easy access to the open metaverse.

Innovative technology and intuitive design collide

Built in collaboration with The Root Network, the Girin Wallet leverages our powerful infrastructure to provide native support for The Root Network and enhance interoperability between the XRPL and our ecosystem. The Root Network’s developer-friendly tools, scalability, and EVM compatibility enabled Girin Labs to efficiently integrate multi-chain functionality and focus on creating a superior user experience.

"The Root Network is a versatile and supportive platform which is providing Girin Labs with the tools and community needed to build scalable, user-focused applications like the Girin Wallet." – Claud, CEO, Girin Labs

Discover a new gateway to web3

Ready to unlock a new tool that lowers the barriers to web3 and enhances interoperability between the XRPL and The Root Network? Simply download the app, connect to FuturePass via the Wallet Connect function, and you’re away. You can find more onboarding guides, feature walkthroughs, and incentives for early adopters on the Girin Labs X account and blog.

Download the Girin Wallet for iOS or Android now:

• App Store
• Google Play

This is more than just a wallet launch – it’s a step towards building a connected and thriving web3 ecosystem for the XRPL and The Root Network. There are plenty of exciting updates planned for the coming months with lending and staking features, expanded multi-chain compatibility, and user experience updates in the works. Girin Labs are also planning incentive programs for wallet users and are constantly looking for innovative ways to introduce new users to The Root Network ecosystem.

Find out more about the Girin Wallet:

• Website: girin.app
• X: @Girin_Labs
• Blog : inblog.ai/girineng
• Docs : girin.readme

Overview

As part of our ongoing mission to decentralize and strengthen The Root Network, Futureverse are introducing an update to the validator commission rates on all their nodes, making now the perfect time to review your nominations and staking strategy.

You can help secure The Root Network by Staking ROOT tokens. Choose to simply stake, or to nominate your stake to one or more Validators. Nominating your stake earns a greater share of block rewards and an increased Bootstrap rewards rate. However, it also exposes you to Slashing risk - a penalty applied if a validator misbehaves. Learn more about our Staking Protocol here.

Why the update?

Starting Dec 15 PT, Futureverse’s operated nodes (21 in total) will adjust their commission rate from the current 1% to 5%. This change is designed to foster a more competitive and rewarding environment for external validators while maintaining the reliability and robustness of the network.

Here’s what this means:

• For Nominators: Rewards may be slightly reduced as a result of the updated commission rate. However, this increase provides external validators with more flexibility to adjust their own rates competitively, and you have the choice and ability to update your selected nominations at any time.
• For the Network: This change creates room for external validators to set competitive rates, increasing their returns and encouraging broader participation in the ecosystem.

We believe this update supports our shared goal of creating a network that is open, decentralized, and sustainable for all participants.

Choosing which Validators to Nominate

This update is an ideal time to take a look at your Nominations. If you choose to Nominate validators to stake with, consider the following factors to maximize your rewards:

• A higher uptime means the validator is more reliable by keeping their node consistently running.
• Commission rates vary which impacts your rewards.
• Ensure the validator is not oversubscribed. Oversubscribed validators may result in reduced or missed rewards for you. Only the top 256 Nominators to a Validator will earn rewards based on the amount of ROOT nominated.

Commission on Staking Rewards

Each validator can set a commission rate, which is a percentage of the staking rewards that they get to keep. The remainder is shared with the nominators based on the amount of ROOT each nominated to this validator.

Updating and Changing your Nominations

Changing your selected nominations is simple:

1. Go to the Staking Dashboard
2. Log in with your FuturePass
3. “Change Nominations,” update your selection, and confirm.

When you update your selected Validators, it takes two Eras (Era = 24hr) to process, meaning that in the third Era after submitting the change, you will see it reflected in your Nominations list.

• Current Era: the task is queued to be broadcast to the Pallet during the rollover to the next Era
• 2nd Era: the task is broadcast to the Pallet to update your selected Validators
• 3rd Era: the task is processed during the rollover to the next Era, and your Nominations will reflect your current selection

Prerequisites

You require a minimum of 25 ROOT tokens in your FuturePass to participate in staking or nominating. Follow the steps in the How to buy ROOT guide to get started.

‍

To get started, update nominations and more, visit staking.therootnetwork.com and launch the app.

Learn more about Staking on The Root Network, see our FAQ’s, and if you require support, please click the ‘?’ in the bottom right of the screen.

The Third Kingdom, powered by Futureverse, in partnership with Walker World, is the latest game to launch on The Root Network. It aims to be one of the leading community-driven experiences in web3, bringing partner collections and their communities together for an interactive adventure and the pursuit of up to 312,500,000 ROOT rewards in Season One alone. The game also offers the first implementation of the Material World Protocol, empowering players to mint in-game resources that can be used across the open metaverse.

Enter The Third Kingdom

Episode 1 - Live now

Players begin their journey on Origin Island. Here, they build extractors to unearth materials, develop their domain, and prestige to generate the power for harvesting Mycelium in Episode 2.

Prysms and SurrealScapes can be strategically deployed on the island to boost production rates, enabling players to prestige faster.

Episode 2

In Episode 2, the adventure will continue with the introduction of Mycelium harvesting and material refining, among other features that broaden gameplay and strategic possibilities. Players can also recruit character collectibles to further develop the island, automate tasks and enhance production rates - enriching their gameplay experience.

The Material World

The Material World is an interconnected and interoperable game economy protocol, allowing players to mint, trade, and use resources that can travel across multiple games and digital experiences where developers choose to integrate them. Built on The Root Network, the Material World Protocol establishes a shared resource economy that empowers both players and developers across the open metaverse.

Unlocking Opportunities for Game Developers

Material World offers game developers a unique opportunity to integrate shared assets across the metaverse, saving them time and resources by using materials that already exist within the ecosystem. This not only reduces development costs but also enables them to tap into a larger player base from other games and experiences within the metaverse.

Additionally, developers can introduce their own materials and items, earning royalties based on the consumption of these assets across the network. With Material World’s API, developers can expand their reach, building companion mobile or web apps that allow players to collect, refine, craft, or trade resources, adding new layers of engagement to their core game.

Learn more about the Material World Protocol in Futureverse’s article and vision paper.

Your Kingdom Awaits

The game is live now. Start harvesting, prestige, and mint your resources in The Third Kingdom. Download the Futureverse Launcher, install the game, create a FuturePass to sign in, and start building your kingdom.

Owners of Prysms and SurrealScapes NFT collectibles will benefit from boosted resource production rates, the ability to generate energy, and deploy more Prysms. Additionally, Prysm owners will unlock Mycelium harvesting in Episode 2 to discover $ROOT and other rewards.

• Starting Out: Begin your journey on Origin Island, your home base in The Third Kingdom. Choose a biome for your island based on SurrealScapes you own.
• Build: Construct the Stone Quarry, Ore Mine, Gem Mine, Ooze Pump, and Gold Mine to harvest essential resources for developing your empire.
• Deploy: Deploy Prysms and stack SurrealScapes on your island to supercharge your resource production and increase the energy you generate each time you prestige.
• Upgrade: Upgrade your extractors to increase the rate at which they harvest resources or how much they can hold before they reach capacity.
• Kingdom Coins: Accelerate your progress with Kingdom Coins! Reroll resource production boosts for your Prysms, skip building and upgrading costs, and optimize your strategy to maximize rewards in The Third Kingdom.
• Prestige: Level up your empire, reset your progress, and generate energy. Each time you prestige, you get closer to unlocking ROOT and other rewards.
• Earn: Harness the generated energy to power Prysms for harvesting Mycelium, used to redeem ROOT. The more energy you generate, the more Mycelium you can harvest in Episode 2.
• Recruit: Enlist your favorite character collectibles to manage buildings, automate gathering processes, and enhance production rates. Coming soon.

Links

Play The Third Kingdom

Follow The Third Kingdom on X

Join Discord

Overview

The Asset Register is a new ledger system and tool suite that enables developers to establish links between assets. It was built because assets in web3 are currently restricted by their linear data composition. Each asset typically only has one corresponding metadata file and there is no way to create connections between assets in disparate ecosystems. By solving this issue we are bringing real-world-like interactivity to assets.

When the idea for the Asset Register was originally conceived, we envisioned representing digital assets just like assets in the real world. This idea is deeply rooted in our vision of augmenting the metaverse, and it is present in all of our products. The concept aims to blur the line between digital and physical, creating a unified experience that brings tangible meaning to digital ownership. This vision has driven every stage of development, guiding us through both the initial challenges and ongoing enhancements.

The Journey to a Custom Ledger System

Initially, we experimented with a smart contract-only approach, which would have allowed us to directly benefit from the verifiability and security of a Layer 1 (L1) network like The Root Network or Ethereum. However, we faced several challenges:

• High gas fees: Making it costly for users to interact with assets.
• Slower verification: Resulting in delays that were unsuitable for our intended user experience.
• Limitations to rich features: Smart contracts alone couldn't support the dynamic, evolving nature of the asset relationships we wanted to create.
• Limited cross-chain compatibility: Bridging between different chains presented both technical and user experience issues.

These limitations led us to develop a more suitable solution using a purpose-built ledger. This system provided the flexibility needed to create a rich user experience without compromising the core principles of blockchain-based security and verifiability. The system was built to overcome the cost and speed limitations to help make it a foundational pillar for the future of asset management in the metaverse.

Key Principles of the Asset Register

Cross-Chain Accessibility

The most crucial feature of the Asset Register is its accessibility across multiple chains that support NFT and SFT standards. Starting with EVM chains, we have enabled cross-chain interactions via asset linking, removing the need for bridging and allowing creators to use their preferred blockchain. This approach is being utilised by The Next Legends collections, where users can equip their boxers—which can be owned on Ethereum or The Root Network (TRN)—with accessories minted on The Root Network.

Our approach to cross-chain accessibility focuses on giving creators maximum flexibility. By eliminating the need for traditional bridging, we have simplified the user experience and reduced potential risks and complexities. This cross-chain support extends beyond just compatibility; it brings true interoperability, allowing assets to seamlessly interact and be enriched by elements across ecosystems.

Interoperability

Inspired by token standards like ERC721, ERC20, and ERC1155, we aim to create a standard that allows any party to plug into the system. Our schema system describes compatible "equips" for any asset, enabling developers to dynamically create UIs that work for any asset with a registered schema. This makes interacting with assets more seamless and intuitive, as seen in applications like AR Docs Manage Assets.

Interoperability is at the heart of our metaverse vision. With the Asset Register, we are building an open ecosystem where assets can transcend individual platforms and adapt to new environments. The schema-based approach not only provides flexibility but also ensures that the metadata remains structured and meaningful, enabling a wide variety of use cases. Developers can easily build on top of this system, fostering innovation and collaboration across projects.

Openness and Immutability

The Asset Register is an open system, allowing anyone to interact with it. Any creator can build schemas and register their assets. All transactions are immutable and recorded in the Asset Register history. Instead of chaining blocks, we chain the transactions directly.

Openness and immutability are essential to maintaining trust and transparency within the metaverse. By allowing any creator to contribute and ensuring that all interactions are recorded immutably, we provide a level of transparency that encourages trust. This is particularly important as we begin to fully decentralize the Asset Register where users can confidently engage with assets knowing their integrity is protected.

Design Overview

The core system of the Asset Register follows blockchain principles while making key modifications to enhance performance and user experience. We aimed to design a system that is both technically robust and user-friendly, bridging the gap between the often complex blockchain backend and the front-end user experience that consumers expect.

Transactions

Transactions are designed to be easily readable by users before submission, ensuring transparency without needing custom wallet parsing. Upon submission, transactions are immutable and verifiable, supporting a wide range of wallets for EVM, substrate and XRPL.

This ease of transaction readability is an important feature, as it puts power into the hands of users, ensuring they have full visibility into what actions they are authorising. By integrating with multiple wallets, we also make it easier for users across different ecosystems to interact with the Asset Register, further enhancing its accessibility.

Event Streaming and Transaction Processing

We have developed an event stream that can be subscribed to and used by services such as the PFP viewer in Party Bear Swappables, which updates whenever a user modifies the equip tree of a Party Bear. Technically, there are no blocks; every transaction is processed in sequence, which helps speed up validation while maintaining verifiability.

Event streaming allows for real-time updates and interaction, a crucial element for the dynamic and evolving environments of the metaverse. By allowing services to subscribe to changes, we create a highly responsive and interconnected ecosystem where updates are immediately reflected, enhancing the overall user experience.

Challenges and Solutions

Efficiency and Future Decentralization

One of the primary challenges was creating a system that could perform efficiently while still being suitable for future decentralization. This required a deep understanding of blockchain systems and an innovative approach to overcome existing limitations.

Schema System for apps

We developed a separate schema system as a guide for applications rather than imposing constraints directly on asset linking. This system allows for greater flexibility in managing asset metadata, ensuring that developers can design dynamic and adaptable user experiences without being restricted by rigid definitions. By providing a framework that supports interoperability and scalability, the schema system helps facilitate a diverse range of use cases, making it easier for developers to build and innovate on top of the Asset Register.

Balancing Performance and Decentralization

Performance was a significant concern as we sought to balance the need for speed with the requirements of verifiability and decentralization. To address this, we created a system that uses schemas not as rigid constraints but as adaptable guides, allowing for innovation while retaining consistency. Our efforts towards educating developers and providing robust tooling are critical in overcoming these challenges and making the platform accessible.

Developer Tooling and Early Examples

We also made a big push for developer tooling to educate engineers interested in integrating the  Asset Register. Since the Asset Register is a brand-new interaction layer for assets, visualizing new concepts was crucial. Our first in-house experiences, such as The Next Legends Locker Room and Party Bears Unleashed, helped showcase what is possible and provided developers with tangible examples. These early examples served as proof points for the versatility and potential of the Asset Register, inspiring further innovation and adoption within the community.

The Path Ahead

Decentralizing the Asset Register

Our next steps involve further decentralizing the Asset Register by making it a core protocol on the Sylo Network. In doing so, the Asset Register functionality will become an integral part of the data layer of the metaverse while bringing a new level of verifiability to asset-to-asset relationships across ecosystems. This migration will be seamless, porting existing data and introducing a new transaction scheme that will be familiar to current Asset Register users. We are committed to maintaining accessibility, transparency, and efficiency as we move towards a more decentralized, open metaverse.

By running on The Root Network, we inherit all the security guarantees of The Root Network while ensuring that asset relationships are governed collectively, without reliance on a central authority. This shift will not only improve verifiability but also open up new possibilities for collaboration and community-driven growth. However most importantly, decentralizing the Asset Register is about more than just enhancing security and trust—it is about empowering users and developers.

Ensuring a Smooth Transition

The migration to a decentralized system will be approached carefully to ensure that all existing data is preserved and that users face minimal disruption. Our goal is to make this transition as smooth as possible, leveraging familiar transaction schemes and maintaining the features users value. As we embark on this journey, we are also exploring new ways to enrich asset interactions, including enhanced metadata features, more robust developer APIs, and deeper integration with other blockchain networks.

Future Evolution of the Asset Register

Ultimately, the future of the Asset Register is one of continued evolution. By embracing decentralization, fostering interoperability, and empowering creators, we are laying the groundwork for a truly open metaverse. The Asset Register will continue to grow, adapt, and push the boundaries of what is possible in the digital world, driving the next generation of asset management and digital ownership.

Learn more about the features and custom pallets The Root Network has to offer here. To stay up-to-date with developments and join our growing community, follow us on X and join our Discord.

Overview

We’ve teamed up with XRPL Commons and Futureverse for an action packed two-day training at XRPL Commons HQ in Paris November 4-5. Though a little coding experience is needed, whether you are a newbie or an expert, people of all backgrounds are welcome to collaborate and expand their skills in this emerging technology, and even better is it’s completely free! This two-day session will focus on exploring and discovering how to build for an open and interoperable metaverse with The Root Network and Futureverse.

By the end of this training, students will be able to:

• Understand the vision and principles of The Root Network
• Explore blockchain fundamentals and develop using The Root Network’s APIs, SDKs, and services.
• Gain hands-on skills to build applications with innovative blockchain solutions.

Meet The Instructors

Marco Brondani, Co-Founder and CTO Futureverse

Marco Brondani is a visionary leader in technological infrastructure, spearheading advancements in interoperability and multi-chain blockchain technology. His primary focus is on creating seamless technology solutions that bridge different blockchain ecosystems, making complex technologies accessible and invisible to users. With over two decades of experience, Marco is instrumental in driving Futureverse’s mission to revolutionize blockchain and metaverse technology, enabling open, scalable, and interoperable experiences for the future of the internet. Under his leadership, Futureverse has developed groundbreaking initiatives like the The Root Network and the Universal Blueprint Framework. Marco also plays a key role in forming strategic partnerships at Futureverse with global icons such as FIFA, Reebok, Snoop Dogg, and Readyverse Studios.

Rich Deane, Senior Full Stack Developer Futureverse

Rich (Richie) Deane is a Senior Full Stack Developer and Solutions Engineer at Futureverse. When he's not building user experiences, he's collaborating on Futureverse SDKs and assisting developers in building on The Root Network with Futureverse Tools. Prior to joining Futureverse, Richie ran a web agency in New Zealand for the better part of a decade, working on projects for brands like Volvo, Mazda, and Ramada, among many others.

Agenda

Day 1:

• An introduction to Futureverse and The Root Network
• Intro Developer tools for The Root Network
• Intro to Pass, identity for the metaverse
• Listen to testimonials on working on The Root Network, find out why people choose to develop here and what they learned from it.
• Native runtime vs EVM
• Q&A

Day 2:

• Intro to the Futureverse Platform from a developer perspective
• Understanding the tech behind interoperability for the open Metaverse
• Futureverse's vision for interoperability with the Asset Register, cross-chain services, and Connectibles
• Altered State and Jen, generative AI for everybody
• Q&A
• Networking

What will you learn?

Collaborative Spirit

Led by two experienced instructors, the training will take place at the new office of XRPL Commons, located in the heart of Paris. Participants will engage in a collaborative, immersive and relaxed environment, working closely with the senior devs and fellow developers to code and learn together.

Learning by Doing

Participants will have the opportunity to gain hands-on experience and valuable knowledge in building real-world assets on the  The Root Network and XRPL blockchains. This two-day, free training program is designed for developers who have a keen interest in learning about true content interoperability and an immersive open metaverse.

Contribute to the Community

This training offers a great opportunity to gain skills and make the first steps with the broader XRPL ecosystem with The Root Network and Futureverse.

Space is limited, register now!

Readyverse Studios, has shared a first glimpse at WIP gameplay from battle royale OPEN, and player traversal to Promptopia, an experimental AI sandbox in The Readyverse, both in development on The Root Network. This advanced AI-powered tool brings a new level of creativity and customization to gaming, allowing both gamers and developers to generate environments, objects, music, and more using simple text prompts.

Promptopia offers an immersive sandbox experience where players can turn their ideas into reality. By leveraging the latest in generative AI technology, users can create game-ready assets and environments within The Readyverse ecosystem—a platform already featuring iconic collaborations with brands like Reebok, Cool Cats, DeLorean, and Ready Player One.

Revolutionizing Game Design with AI

What sets Promptopia apart is its seamless integration of generative AI into gameplay, giving players the ability to build and share in-game content without any specialized design skills. From interactive objects to AI-generated soundtracks, the possibilities are endless. The tool invites users to become instant creators, blending multiplayer gameplay with real-time asset generation.

Co-Founders of Readyverse Studios, Aaron McDonald and Shara Senderoff, describe the project as a groundbreaking blend of AI and game mechanics.

“Promptopia builds the groundwork for the user-generated content (UGC) experience in The Readyverse,” they said. “We’re giving players the power to bring their imaginations to life, making prompt engineering a core part of the gameplay. It’s designed to be fun and accessible for everyone, regardless of their technical background.”

Empowering Creators with Simple Text Prompts

At its core, Promptopia democratizes game development. By using the innovative "Altered State" 3D model from Futureverse and music generation platform Jen, players can create fully interactive worlds with nothing more than a text prompt. Whether designing expansive landscapes or composing original soundtracks, Promptopia provides all the tools necessary to shape unique in-game experiences.

This new offering underscores Readyverse Studios' commitment to pushing the boundaries of digital creativity, empowering users to take control of the game design process in an intuitive, social environment. As the gaming industry continues to embrace AI, Promptopia stands as a key milestone in the evolution of user-generated content.

With its debut at Permissionless III, Promptopia is set to redefine the creative possibilities within gaming, allowing anyone to transform their imagination into a playable reality.

The future of gaming is built on The Root Network.

Promptopia is coming early 2025.

Sign up now for early access.

Follow The Readyverse on X.

Readyverse Studios today announced a partnership with Oscar-winning special effects and prop company Wētā Workshop for the development of its upcoming multi-genre battle royale game, OPEN, built on The Root Network.

Wētā Workshop, known for its work on The Lord of the Rings and Avatar franchises, will contribute to shaping the visual and narrative aspects of OPEN. In addition, Readyverse Studios has partnered with Neo Tokyo to integrate its IP characters, Citizens, into the game.

OPEN’s immersive multiverse will feature nostalgia-infused biomes with characters and cultural legends across iconic franchises. Challengers embark on game-show styled, multi-round collaborative and competitive game modes, but only one hero can emerge victorious.

Among additional globally recognized IP, such as Reebok, Cool Cats and Delorean Motor Company featured in the teaser, OPEN will feature a Ready Player One biome where fans can engage in competitive experiences born from the novel and film itself; including branded environments and skins.

In a joint statement, Readyverse co-founders Aaron McDonald, Shara Senderoff, Dan Farah, and Ernest Cline emphasized that working with Wētā allows for the creation of unprecedented content in gaming. Wētā's Sir Richard Taylor added that the collaboration enables exploration of an immersive world like nothing they have done before.

OPEN is currently in development for PC, PS5, and Xbox Series X|S. It features third-person battle royale gameplay with environments inspired by media nostalgia, offering both competitive and cooperative modes. The game also incorporates cutting edge metaverse technology for asset interoperability and digital ownership, powered by Futureverse and all built on The Root Network.

The development team includes veterans from studios such as Epic, DICE, Microsoft, PlayStation, Remedy, EA, Ubisoft, and Lucasfilm.

‍

Learn more about OPEN in our previous article.

Sign up for OPEN early access here.

Follow OPEN on X.

Follow Readyverse Studios on X.

‍

‍

Overview

The Root Network’s XRPL Bridge allows the secure and decentralized transfer of tokens between The Root Network and the XRP Ledger, enhancing liquidity and bringing cross-chain functionality to assets on the networks.

Recent updates to the pallet-xrpl-bridge include extending the XRPL bridge to allow for two way bridging of any token between the XRP Ledger and The Root Network.

At the time of writing there are two platforms live offering token bridging between the XRPL and The Root Network; Dexter and FuturePass.

Dexter

Easily bridge ROOT, XRP, ASTO, SYLO and ZRP tokens between the XRP Ledger and The Root Network on Dexter’s newly launched bridge.

FuturePass

The FuturePass Dashboard offers a variety of bridging options for both XRP Ledger and Ethereum Networks. This update expands the options for token bridging between the XRP Ledger and The Root Network to include ROOT, XRP, ASTO, SYLO and ZRP.


Issuers addresses for tokens on the XRP Ledger can be found easily via xrpl.services or directly on DEX's, here are a few:

• ROOT: r9MrRER8UKSAumcqvbwCAsyWbUKomz68i3
• ASTO: rpFEEHBkoFwK3J9Mzi426PvTzGEMZizEh1
• SYLO: rNhK8hNWEjsXvfGE4Lzso517ms6odD7dnn

Pundi X, a pioneer in blockchain-based payment solutions, has entered into a Memorandum of Understanding (MoU) with Futureverse, a leading AI and metaverse company. This strategic partnership will focus on integrating AI and blockchain technologies to enhance both ecosystems, driving forward the development of decentralized finance, metaverse payment solutions, and AI data innovation.

Key Areas of Collaboration:

• AI Integration: Building an AI DATA Omnichain Layer on Pundi AI
• Pundi AI layer to serve as a foundation for the new AI Data Omnichain Layer: This will allow Futureverse creators and consumers to generate AI data tokens for their work. The data will be processed on The Root Network (TRN), with Futureverse users having the opportunity to earn rewards by contributing their AI data annotations through Pundi AI.
• The Root Network Integration: The Root Network (TRN) will be integrated into key Pundi X services, including f(x)Wallet and the p(x)card app. This integration will extend to the upcoming Decentralized XPOS platform, which will also support TRN, further enhancing the interoperability of the Pundi X ecosystem.
• Bringing Payment to the Metaverse: Pundi X’s payment system will be integrated into Futureverse’s Readyverse, providing a seamless payment experience within the metaverse. This integration will offer users various payment options, bringing real-world financial solutions into the digital realm.
• Onboarding Pundi X’s SocialFi Platform Purse+: Futureverse and The Root Network communities will be onboarded onto Purse+, Pundi X’s innovative SocialFi platform. This will enable users to earn rewards and engage more deeply within the Futureverse ecosystem, leveraging blockchain technology for enhanced user interaction and community growth.

Zac Cheah, CEO of Pundi X, expressed his excitement about the partnership:

“This MoU marks a significant step forward in our mission to make blockchain technology and digital payments more accessible. By integrating Futureverse’s innovative platforms with our Pundi AI and Pundi X payment solutions, we’re bringing the future of finance and AI into the metaverse, creating new opportunities for creators and users alike.”

Aaron McDonald, CEO of Futureverse, added:

“Our collaboration with Pundi X is a testament to the growing importance of integrating AI, blockchain, and digital payments within the metaverse. By leveraging the strengths of both companies, we are laying the groundwork for a truly decentralized and inclusive digital economy.”

About Pundi X Labs

Founded in 2017, Pundi X delivers web3 and AI technology to build a more accessible and inclusive world. Through its innovative products, including from the world first blockchain-based point-of-sale platform XPOS, AI data omni-chain layer Pundi AI Chain to SocialFi browser plug-in for x.com, Purse+, Pundi X is transforming the way people use and interact with cryptocurrencies, driving financial inclusion on a global scale.

Headquartered in Singapore, Pundi X has also been selected as one of the top 50 Innovative Fintech Startups in 2018 by KPMG and H2 Ventures, cool vendors in blockchain business by Gartner, and one of the top 10 fintech leaders by Singapore Fintech Association in 2019.

For more information, visit pundi.ai.

About Futureverse

Futureverse is a cutting-edge technology company focused on building the open metaverse. With platforms like Readyverse and The Root Network, Futureverse is pioneering the next generation of digital experiences, combining blockchain, AI, and immersive technologies to create a connected and interoperable digital world.

For more information, visit futureverse.com.

‍

The highly anticipated integration of the Zerpmon game and The Root Network is here. Let’s take a closer look at this innovative and evolving digital TCG and find out how it’s expanding the reach of XRP-powered gaming through multi-chain support.

Get to know Zerpmon

Zerpmon – a creature-collecting and battling-style digital TCG from Gen3 Games – is now integrated with The Root Network. The core gameplay revolves around building a deck of between one and five Zerpmon in the most strategic way possible. Each Zerpmon has a unique move set and playstyle, with players using Equipment and Trainers to beat the highest-stage Gyms and earn rewards like ZRP and extremely rare Zerpmon collectibles.

A mix of skill-based strategy and player-friendly auto-battling mechanics sets Zerpmon apart from others in the genre. By integrating AI into the development process, the project enables the creation of large volumes of high-quality art for every creature. The game has significant depth around the move sets for Zerpmon, with each one featuring a unique playstyle. The art style is inspired by various aspects of pop culture, creating innovative, nostalgic gameplay accessible to everyone from casual players to seasoned pros.

Game development on the next level  

Zerpmon uses The Root Network to tokenize a new type of game card that evolves over time, with plans well underway to bridge its core reward token, ZRP, onto the network as well. Users from The Root Network can own, buy, and trade Zerpmon assets using a FuturePass. Plus, anyone can play the game from The Root Network, XRP, or both.

"Our team is so grateful to be building on this awesome technology with an incredible community of people behind it." Shen Morincome, Co-Founder and CEO of Gen3 Games.

Building on The Root Network is opening up new opportunities for Zerpmon. It allows them to interact with EVM contracts alongside XRPL-issued assets and gain access to a wide variety of AI-powered game development tooling through Futureverse. They’re also able to take advantage of mentorship and advice from The Root Network team throughout the building process.

A player-focused minting experience

To kick off its integration, Zerpmon has launched a limited-time mint of collectibles on The Root Network accessed through Tradeverse. When players mint a Zerpmon card, they score a free secondary Trainer or Equipment card, providing instant access to all parts of the game. The team is also planning a ROOT and ZRP airdrop for anyone who mints to ensure more comprehensive access to the Zerpmon starter pack with key collectibles and a bag of tokens to spend in the game.

After minting, it's easy to start playing straight away. Players can:  

• Open the Zerpmon web app at app.zerpmon.world.  
• Sign in with FuturePass. If they already play with an XRPL wallet, they can link a FuturePass to their existing Zerpmon account.  
• Visit the Decks tab of the app to add newly minted Zerpmon to their current Decks.  
• Click on the Battle tab and play any of the game modes.  

Different modes feature a range of rewards like Zerpmon XP, Trainers XP, XRP rewards, and ZRP rewards – so trying a few modes is recommended.

A rapid development process, constant iteration, and regular releases of new features and game modes make this project one to watch. The team is excited to have their core platforms fully integrated and operational and plans to continue developing Tradeverse and Zerpmon on The Root Network. Through Tradeverse, Zerpmon, and other initiatives, Gen3 Games hopes to be a catalyst for growth, inspiring others to build on The Root Network.

Links

Play Zerpmon Game

Follow Zerpmon on X

Join the Zerpmon Discord

Overview

The Root Network is built on top of the open-source blockchain framework Substrate. We have adapted this with many enhancements known as pallets to deliver on our goals of driving better ux and more interoperability for open gaming. Substrate (now known as Polkadot SDK) is maintained by a large open source community lead by Parity Technologies.

The Root Network was initially created using an older Substrate version v0.9.27. The journey to v1.0.0 started a few months back. First, we upgraded the node to v0.9.30 covering 3 main releases with The Root Network release v4.41.0, followed by the largest jump we have ever seen in The Root Network’s history, v1.0.0, covering 14 major releases. 🤯

The Requirement

The Substrate framework is a highly active, fast-paced codebase where developers constantly introduce new features, bug fixes, and improvements. Being on an old Substrate version hinders the ability to introduce these new advancements to The Root Network. Hence we need to transition The Root Network to Substrate v1.0 smoothly, with minimal disruption to the network. And where’s the fun in living in the past without stepping into the future? Working with the cutting-edge technology is much more rewarding.

Benefits

The new upgrade release comes with many benefits.

• The Root Network will get all the new features, bug fixes, security patches, tooling, performance and efficiency improvements and new protocols developed by the upstream Substrate framework. For details refer to Pull Request #821.
• The Root Network will be prepared for much faster and streamlined future upgrades.
• This upgrades supports Shanghai EVM version, a framework the whole eco system will be able to benefit from.
• Update maximum block weight of 1 second, allowing more space within a The Root Network block, increase in transaction throughput.
• Gas benchmarking redone on the standard hardware. An optimized value of 15 million for the block gas limit, up from the previous value of 11 million.
• Open the door for the next stage of The Root Networks long term architecture.

Challenges

Upgrading to a newer Substrate version is a major milestone the team is excited about, but at the same time, many challenges need to be addressed and resolved, especially if we are sitting on an older codebase.

Substrate codebase is a highly active and very dynamic codebase. Sometimes the structures (structs, traits) in the codebase get completely removed or moved to other places between the updates. Other times even the fundamental concepts might get changed as a result of continuous advancements.

At The Root Network codebase level, we use and reuse the framework code and the structures to build new functionality or develop new structures for the custom requirements of The Root Network. One of the heaviest tasks of an upgrade is to make the code buildable with new dependencies. Sometimes an entire feature has to be rewritten and updated to accomplish this. During The Root Network upgrade, we faced a number of such challenges. Some of the major ones are listed below. For the full changeset refer Pull Request #821.

• A big refactor was done to the framework asset handling traits with “introduce holds and freezing into fungible traits” PR - Pull Request #12951. We had our custom AssetExt  pallet and multi asset handling custom code written on top of the old logic/concepts. But with the upgrade we had to rewrite/update most of that code.
• Frame v1 was deprecated with Pull Request #13705, but it was broken already with the removal of the block number in Pull Request #14437. The Root Network had two pallets that were on Frame v1 code, Ethy and Erc20-peg , out of which Ethy is a complex codebase serving many other pallets as well. We had to do a prior release to upgrade these two pallets to Frame v2 before proceed upgrading to Substrate v1.0.0.
• Changes to framework client-side code/services required modifications to The Root Network custom client-side protocols such as ethy-p2p which powers the decentralized bridging and other consensus activities.
• Migrations - Database migrations are one of the major headaches and a deciding factor when it comes to Substrate upgrade planning. When jumping across 14 major releases, one must be very cautious regarding the migrations. Missing an important migration could lead to a far more serious problem from corrupt data to completely bricking the network. Database migrations could be client-side or runtime. With this upgrade we did not find any client-side migrations, but many runtime db migrations. More about how we get around the migrations in the planning section.

Planning and Execution

Prioritizing Migrations and Data Loads

The first step of this journey was to undertake a feasibility study to gather and document all the details. In the first round each major release starting from v0.27.0 to v1.0.0 in both Substrate and Frontier repositories was analyzed. The main focus of this round of migrations was to identify any migrations and list them with as many as details possible.

Then shortlisting of the migrations to those relevant to The Root Network was done. We are mainly interested in migrations of the runtime pallets that are being used by The Root Network runtime, other runtime migrations can be excluded.

The next step is to check how heavy the migration data is. For runtime migrations, the migration would happen at the start of the next block mint once we set the new runtime code. It is important to notice that during this period the nodes have higher resource utilization and we have a limited time to apply the migrations before the next block mint. If the validator nodes are unable to apply the migrations on time, it will cause them to miss the slots and delay the chain. And the nodes will also be on high-stress conditions if that happens. Therefore it is important to get a sense of the load introduced by the amount of data that needed to be migrated over. In this step, both testnet Porcini and mainnet Root relevant data was analyzed and documented.

Any migration that can be excluded for any valid reason has to be removed to reduce the load. It is also important to note that multiple migrations within the same runtime pallet need sequencing so that it won’t cause any issues when the upgrade is underway. Additionally there were extra migrations to upgrade all the accounts in the network as a part of Pull 12951.  These migrations needed to be executed once we finish the runtime upgrade.

Updating The Root Network codebase

The next step is the single most difficult task of the whole upgrade, upgrading The Root Network codebase and making it buildable with new dependencies. Most of the task has to be done by a single person since the opportunity to parallelize this task is very slim. Hence it took a considerable amount of time to complete.

Testing, Testing and more Testing

Next comes the deployment of devnets. We created two devnets Sprout1, Sprout2 each for Porcini and Root with having the forked state of each network. The idea here is to run a new network on a snapshot of Porcini/Root data so that we can do the upgrade and check the status, do functional testing, and post-upgrade monitoring before we go for a testnet/mainnet release. Each important step was documented to ensure we would follow the same plan during testnet/mainnet rollout. Most of the peripheral services such as indexers, explorers, and relayers were pointed to the new devnets in order to achieve complete functional testing. Internal QAs, as well as downstream application teams, were also involved in testing on devnets.

Apart from functional testing on devnets, a separate testing effort was carried out for mixed runtime testing and load testing. Here the idea was to simulate the actual upgrade scenario on devnets. The Substrate upgrade consists of two main segments, A client deployment and a runtime upgrade afterward. The new client rollout can take up to hours depending on how fast it goes. During this time there will be situations like new clients running old runtime and old clients running old runtimes. Also once the runtime upgrade is done, there will be scenarios like new clients running new runtime and old clients running new runtime. Note that The Root Network is a decentralized blockchain and there is no way we can upgrade all the nodes in the network at the same time durations. The idea of this testing is to make sure that under any of these mixed scenarios client-side protocols such as babe, grandpa, and ethy can function nominally. This would make sure the liveliness of the network during and after the upgrading process.

Once the devnet testing was at a satisfactory level, the next step was to go for testnet release. Porcini was upgraded with the new release image and then upgraded to v8.56.0 which essentially includes the Substrate upgrade plus a few more improvements and optimizations at The Root Network codebase. Then more testing on Porcini was carried out.

Once we are satisfied with the Porcini it’s time for the grand finale, the mainnet upgrade, and post-testing and monitoring.

Go time

Substrate upgrade has been one of the major projects that went underway in The Root Network history, thanks to everyone who contributed including the Core Dev team, Devops, QAs, PMs and Management, downstream project Dev and QA teams, external developers and testers, marketing, and comms.

The Future

It is exciting times ahead. We upgraded The Root Network to the landmark Substrate v1.0.0 release. Now it’s time to move forward much faster with the new polkadot-sdk repository, Substrate has moved to this new repository after the v1.0.0 release. Keeping up to date with Substrate and Frontier and developing with the latest technology is going to be very rewarding.

Learn more about the features and custom pallets The Root Network has to offer here. To stay up-to-date with developments and join our growing community, follow us on X and join our Discord.

Overview

Girin Labs, a Korea-based Web3 venture studio, announced that it has secured funding from the recently launched XRP Ledger (XRPL) Japan and Korea Fund backed by Ripple, the global leader in enterprise blockchain and crypto solutions. The funding is set to accelerate Girin Labs’ development of two core products, the Girin Wallet and the Lotus Protocol.

This marks the first funding from the XRPL Japan and Korea Fund and the first time Girin Labs has officially secured global funding outside of Korea.

Girin Labs

Girin Labs is a venture studio focused on developing integrated infrastructure for web3 and consists of experts with extensive experience in mainnet and web3 startup strategy and product development. Ripple’s accelerator partner in Korea, Catalyze Research, will provide various strategic and advisory services necessary for project expansion.

With the funding, Girin Labs will accelerate its development of the Girin Wallet, a XRPL-focused wallet, and the Lotus Protocol for decentralized finance (DeFi) services.

• Girin Wallet - Girin Labs flagship product, aims to build a user-friendly infrastructure that will enable XRP holders to leverage Dapps on the XRPL. With its social login feature, it enables anyone to easily onboard to the XRP on-chain network.
• Lotus Protocol -  the first lending and liquid staking token (LST) protocol on The Root Network, offering sustainable yield farming for XRP & ROOT holders.

Furthermore, Girin Labs expressed its ambition to become a key DeFi player within the ecosystem by working closely with major partners, including Futureverse.

The XRPL has been globally recognized and trusted for over a decade as an enterprise-grade blockchain, with its built-in capabilities like tokenization, a native decentralized exchange (DEX), compliance features and more. Girin Labs aims to act as a catalyst for the XRPL’s further growth by adding more utility.

Josh Kim, Chief Strategy Officer of Catalyze Research, commented on the funding, saying, "Girin Labs' main products will play a crucial role in the growth of the XRP Ledger. Approximately 50 million XRP holders worldwide are looking for more ecosystem utilities based on on-chain and real-world applications, which is the key agenda Girin Labs aims to address."

Ripples Support for Builders

On June 11th, 2024, Ripple announced the launch of the XRPL Japan and Korea Fund, as part of its 1 billion XRP commitment to provide financial, technical, and business support for developers and entrepreneurs building on the XRPL – through both the XRPL Grants and XRPL Accelerator programs. The Fund plans to support leading projects in Japan and Korea and foster innovation on the XRPL.

‍

Overview

ASM share their latest paper, outlining three new core components to their ASM AI Protocol. These components are designed for scalability, interoperability, and usability for developers working at the intersection of web3 and AI.

With three games in-market and using B.R.A.I.N.S. in different ways, they've learnt a lot around how the ASM AI Protocol can interact with games and agents. They're taking these learnings to adapt the Protocol and unlock the full potential of web3 and AI coming together.

Read the full ASM paper here.

ASM Non-Fungible Intelligence (NFI) Protocol

The first new core component is the ASM Non-Fungible Intelligence (NFI) Protocol built on The Root Network. This new protocol is designed for scalability, allowing anything in the open metaverse to be made intelligent, from avatars to objects, even metaverse land.

But what is Non-Fungible Intelligence? The Patented ASM Protocol links on-chain data to AI agents, enabling developers to build interoperable AI powered experiences and assets that users can own.

The heart of the ASM NFI Protocol is a substrate pallet that enables any user or creator to mint new Non-Fungible Intelligence aka B.R.A.I.N.S. into any existing upgraded NFT or create new NFTs / SFTs, cross-chain with intelligence built-in.

ASM Launchpad Protocol

The ASM Launchpad Protocol is the second core component. This offers a revolutionary approach to managing the licensing of ASM technologies. With tokenized licensing, developers gain the protection of ASM patents and the ability to leverage ASM innovations on any chain.

This method of tokenized licenses, is patent pending and could be used to manage other Futureverse and ASM patented technology.

ASM Void Protocol 2.0

The ASM Void Protocol 2.0 is the third core component and is a system developed for $ASTO holders to benefit from the value generated by the above two protocol services.

The Void Protocol 2.0 leverages The Root Networks innovative staking mechanism, The Vortex. $ASTO holders staking on the ASM Void Protocol 2.0 are rewarded with ASTO-Energy. At the end of each cycle, ASTO-Energy can be exchanged for ASM Void tokens, and/or for NFTs vested in the protocol.

ASM Void tokens will be tradable on The Root Network DEX, assuming there is a liquidity pool with a pair of your choice, or can be unwound by users to redeem an equivalent value of any of the unlocked $ASTO or project tokens within the ASM Void pool.

Existing B.R.A.I.N.S. remain a foundational piece of the ASM AI Protocol, their Genomes can continue to be used in existing games like RAICERS. Developers can still integrate these ASM B.R.A.I.N. collections in their experiences and continue to utilize their tech.

In an upcoming season of The Third Kingdom, Gen II B.R.A.I.N. holders will have the opportunity to transform their B.R.A.I.N.S. into Intelligent SurrealScapes.

ASM is committed to pushing the boundaries of what’s possible with AI and web3 and fostering a mutual ecosystem for builders and users.

Read the full ASM paper here.

‍

Overview

The Root Network Substrate framework is upgrading to v1.0.0. This brings a range of benefits for builders on the network, including security patches, performance and efficiency improvements, new protocols and streamlining for future upgrades.

A summary of the major changes with the upgrade are outlined here.

This week we’ll be pushing the upgrade from Spout-1 (Devnet) to Porcini(Testnet) for further QA, moving one step closer to production (Mainnet).

The Move to Porcini

On 24 July UTC the Substrate upgrade will move from Spout-1 (Devnet) to Porcini (Testnet), after which we invite developers to begin thoroughly regression testing all key functions that touch The Root Network on Porcini. This is the final step before upgrading to Mainnet, further updates will contain specifics of this.

Known Issues

Please review the current known issues for the Substrate upgrade and see if it's a change required on your side for any problems.

Developer Support

For questions and support when testing please reach out to support@therootnetwork.com.

Connecting Sprout

A priority moving forward is to ensure smooth transitions for any future upgrades; thus, we have launched a developer environment layer for experiences and services to connect to and test on on The Root Network, Sprout-1 (Devnet). This is in addition to Porcini (Testnet) for QA, and Mainnet for production. We highly encourage all builders to connect to and build out support for Sprout-1. Note, we do not require any further testing on Denvet for the current Substrate upgrade.

You can find the information to connect to the Devnet Sprout-1 here.

Stay tuned for more details as we move through testing and implementation of Substrate v1.0.0.

‍

‍

‍

Introducing Tradeverse

Today marks the launch of the public beta for Tradeverse, a groundbreaking gamified marketplace on The Root Network. Powered by XRP and ROOT, Tradeverse promises a new era in NFT trading.

Gen3 Games, led by Co-Founder and CEO Shen Morincome, is the driving force behind Tradeverse. Shen has over three years of experience building platforms within the blockchain space, particularly on the XRPL, Shen leverages his game design background to create innovative and engaging blockchain experiences. His focus is on increasing on-chain participation through gamification.

Building on The Root Network

"Transitioning from XRPL to The Root Network was seamless due to the native integration of XRP and XRPL assets. As a game development team, having access to Futureverse’s advanced AI tech tailored for game development is immensely valuable. The combination of using XRP natively, accessing powerful AI tools like DOC, DOT, and Jen, and utilizing smart contracts makes The Root Network ideal for our XRP-focused game studio." says Shen Morincome, Tradeverse CEO and Co-Founder.

Explore Tradeverse

In Tradeverse, you can buy, discover, and trade your favorite collectibles. This first iteration of the platform is just the beginning. They are eager to collaborate with the community to enhance it further and encourage everyone to share their feedback. Join their Discord to share your thoughts.

They will also debut their gamified minting mechanism this week with Root Punks mint. This minting experience is available to any project releasing their collection through Tradeverse, and will offer custom variations for specific projects and mints.

Built For The Future

Trade

Buy, sell, or trade Root Network NFTs and collectibles seamlessly. Powered by ROOT and XRP, Tradeverse is a gamified marketplace tailored for gaming assets.

Mint

Unleash your creativity in the Tradeverse by minting your own NFTs. Leverage the power of The Root Network to design, produce, and showcase unique digital assets while engaging with a vast community of creators.

Explore

Explore the world of Root Network collectibles through The Tradeverse. An NFT ecosystem powered by ROOT & XRP, tailored for interactive AI -driven experiences and games.

Earn Rewards

Be rewarded for participating in the Tradeverse through tokenized trading rewards. Season 1 beginning soon.

Links

Visit the Tradeverse website here.‍

Visit the Tradeverse X here.

‍

The ethically-trained generative AI music platform introduces a new standard for copyright compliance in text-to-music generation.

With over 40 fully-licensed catalogs in its initial training set, Jen adheres to a strict training doctrine that emphasizes its commitment to transparency, compensation and copyright identification. Jen's prompt-based flow simplifies the creative process, while also providing assurance that all outputs respect both artists and industry copyright standards.

"We have reached a defining moment for the future of the music industry. To ensure artistry maintains the value it deserves, we must commit to honor the creativity and copyrights of the past, while embracing the tools that will shape the next generation of music creation," said Jen Co-Founder and seasoned music tech entrepreneur Shara Senderoff. "Jen empowers creators with tools that enhance their creative process. Jen is a collaborator; a friend in the studio that works with you to ideate and iterate. As we bring Jen to market, we are partnering with music rights holders and aligning with the industry at large to deliver what we believe is the most ethical approach to generative AI."

Jen's best-in-class technology, powered Futureverse, has been developed by its team of distinguished PhDs and scientists whose work on Jen's published research papers have been acknowledged by prestigious journals and cited by Meta's AI Lab, Meta FAIR, Sony AI and Bytedance AI; a true testament to their deeply architected music research approach.

From novices with a song in their hearts to professional producers, Jen empowers creators to bring their musical visions to life and push the boundaries of creativity. Featuring proprietary, high-fidelity, waveform-based diffusion models that leverage a unique neural network architecture, Jen offers sophisticated music generation capabilities in high-quality stereo audio. A pioneer in the field of AI music with multiple patents pending, Jen is the first generative music platform to complete waveform-based latent diffusion with multiple tasks, including generation, continuation, and inpainting.

Built on Root

Jen's rigorous compliance process sets it apart from the pack. Using The Root Network in unique ways, every track is automatically vetted for audio recognition and copyright identification utilizing a database of 150M tracks. This includes both the compositions in the training set and every newly generated track on the platform.

Jen then generates an on-chain record on The Root Network for each generated track, ensuring the integrity and timestamp of each track's creation, proving it was generated by Jen and by the unique FuturePass account, leveraging XLS-20 NFTs, to track and protect IP rights. Verified song outputs receive a JENUINE™ indicator upon generation.

Jen also introduces R3CORD™, you “record” tracks to The Root Network as cross-chain compatible NFTs enabling on-chain trading (coming soon).

In tandem with today's alpha launch, the Jen research team publishes its third research paper: JEN-1 DREAMSTYLER: CUSTOMIZED MUSICAL CONCEPT LEARNING VIA PIVOTAL PARAMETERS TUNING. This paper details Jen's upcoming StyleFilter™ technology, which allows users to upload a unique instrument, genre, or track to create what's labeled as a StyleFilter, that styles a new masterpiece with the desired sound.

Start using Jen [Alpha] today and enjoy free credits to get started, additional credits can be purchased using credit card or $ROOT, $XRP and other crypto currencies on The Root Network.

What is The Root Network and $ROOT

The Root Network is a layer 1 blockchain, purpose-built for open metaverse activations, utilizing core, UX, and digital content focused protocols to enable seamless user experience and enhance content interoperability. The Root Network features include account abstraction and any token gas economy, enabling some of the world's largest content brands to onboard users seamlessly and safely. The Root Network is EVM compatible, built on Substrate, integrated to XRPL and ETH with other networks on the horizon, allowing content on those networks to access deeper functionality and interoperability.

ROOT is the native token of The Root Network. Used for securing the proof-of-stake network, network fees, and as a base currency within the network.

Refer to the Tokenomics section of our Documentation for more information on supply and distribution.

Storing and Acquiring $ROOT

You will first need a cryptocurrency wallet to store, trade, and receive ROOT tokens. ROOT tokens are available natively on The Root Network as well as ERC-20 on Ethereum.

FuturePass: Your native smart wallet on The Root Network, powered by Futureverse. It’s just like using your Ethereum wallet; safe, secure, with account delegation for enhanced security, and multiple wallet integration options for interoperability.

In order to transfer ROOT tokens to and from The Root Network, they will need to be bridged using the FuturePass Dashboard.

Where to buy $ROOT

There are several ways to purchase ROOT, through centralized exchanges (CEX) and decentralized exchanges (DEX).

Centralized Exchanges (CEX)

ROOT is currently listed on the following centralized exchanges. It’s important to note some exchanges list native ROOT and some the ERC-20 variant, ensure you are aware of which variant you are purchasing.

Centralized exchanges with native ROOT

• Gate.io (Native L1 ROOT)
• BitGet (Native L1 ROOT)
• MEXC (Native L1 ROOT)
• BitMart (Native L1 ROOT)

Centralized exchanges with ERC-20 ROOT

• Kucoin (ERC-20 ROOT)
• ByBit (ERC-20 ROOT)
• Huobi (ERC-20 ROOT)
• Uphold (ERC-20 ROOT)
• CoinDCX (ERC-20 ROOT)

Decentralized Exchanges (DEX)

You can purchase ROOT through decentralized exchanges (DEX). As with the centralized exchanges, there are both native and ERC-20 ROOT decentralized exchanges.

Decentralized exchanges with native ROOT

Users should first acquire funds on The Root Network either through withdrawing from CEXes with native ROOT or ERC-20 ROOT via the bridge (see ‘How to Bridge’ section below)

• Dexter (Native L1 ROOT)
• MOAI Finance (Native L1 ROOT)

These DEXes are also an avenue for users to purchase other tokens on The Root Network like $SYLO, $ASTO and $XRP.

Decentralized exchange with ERC-20 ROOT

• UNISWAP (ERC-20 ROOT)

How to Bridge ROOT

ROOT can be bridged between The Root Network and the Ethereum blockchain. If you purchase tokens from CEX with ERC-20 ROOT, you will need to send the tokens to a self-custody Ethereum wallet and then bridge your tokens to The Root Network to get them into your FuturePass. To do this you can follow the below steps:

1. Log into your FuturePass dashboard.
2. On the ‘Stuff’ page click on the ‘Tokens’ tab.
3. Click on ‘Bridge’.
4. Under ‘Token Name’, select the ROOT you wish to bridge, the small icons signify what chain the tokens are on.
5. Enter the amount you wish to bridge.
6. In the ‘Destination Address’ ensure you are bridging to the desired address.
   1. If bridging to The Root Network it should default to your FuturePass address
   2. If bridging to Ethereum blockchain it should default to your EOA wallet address
7. Click ‘Bridge’.
8. Approve the transactions. It will take approximately 15-20 minutes for the tokens to bridge.
9. If bridging ROOT from The Root Network to Ethereum, there is one additional step. You will need to navigate to the ‘Activity’ tab and ‘claim’ your bridged ROOT. Note: when bridging to the Ethereum network, there will be an Ethereum gas fees to claim the bridge.

For questions and support please contact: support@therootnetwork.com.

Overview​

Wallet support is crucial for any blockchain ecosystem. Wallets serve as the primary interface through which users engage with the blockchain, with this in mind alongside increasing demand for cross-chain interoperability, it has become essential to provide a robust mechanism for transacting across diverse blockchain ecosystems.

In this blog we’ll look at how The Root Network has been looking at ways to improve the user experience for the XRP community, through pallet-xrpl, enabling messages/transactions signed using the XRPL based Xaman wallet, to be accepted by The Root Network.

The Xaman wallet is a mobile wallet that supports the XRP Ledger, our goal was to enable Xaman wallet holders to interact seamlessly, allowing them to sign and dispatch transactions directly to The Root Network. This integration ensures users can engage with The Root Network ecosystem without the need to switch wallets.

With the increasing demand for cross-chain interoperability, it has become essential to provide a robust mechanism for transacting across diverse blockchain ecosystems. pallet-xrpl is our answer to this demand, which would enable Xaman signed messages/transactions to be accepted by The Root Network.

In the following sections, we will share insights from our development journey, outline our high-level integration strategy, dissect the core components of pallet-xrpl, and discuss the challenges we faced along with the innovative solutions we devised.

Stay tuned as we unpack the intricate details of integrating the Xaman XRPL wallet with The Root Network.

Why Support XRPL Transactions on The Root Network?​

The Root Network utilizes a unique multi-token system, where the primary network token, ROOT, is separated from the gas token, XRP, sourced from a partnership with Ripple and the XRPL. The Root Network also has an XRPL Bridge, allowing the secure transfer of tokens between The Root Network and the XRP Ledger.

Given the strong ties with the XRPL and the use of XRP as the underlying gas token, it was imperative for us to meet our users where they are. The Xaman wallet, being one of the most popular wallets in the XRP community, was a natural choice for integration. By supporting the Xaman wallet, we provide a seamless experience for XRP users to interact with The Root Network. This integration not only enhances user experience but also fosters cross-chain interoperability, expanding the reach of our ecosystem. It opens up new possibilities for users, enabling them to transact seamlessly across different blockchain ecosystems.

Problem Statement​

To enable XRPL users to interact with The Root Network, we needed to develop a mechanism that would allow users to sign XRPL messages and submit them to The Root Network.These messages would contain data such as the extrinsic to be executed (or the hash of it) - which would effectively allow an XRPL account to perform actions - i.e. state changes, on The Root Network. We identified the Xaman wallet, a popular mobile wallet that supports the XRP Ledger, as a good place to start.

The challenge was to design a solution that would facilitate the signing of transactions on The Root Network, using schemes supported by the Xaman wallet, then submitting these signed messages/transactions on our network, while maintaining the security and integrity of the transactions. Since these signed messages are not natively supported on The Root Network - i.e. these are not substrate extrinsics; we had to devise a way to support custom Xaman signed messages.

To integrate with the XRPL via the Xaman wallet, we must first understand the architecture of how a request to sign an XRPL message is initiated, the key entities/services involved in this process, and how the signed message/transaction is sent to The Root Network.

Architecture of the Xaman Wallet Integration​

To understand how we could allow an Xaman wallet to sign transactions on The Root Network, we need to first understand how signing requests are sent to the Xaman wallet and then how signed payloads are relayed back to the caller.

1. In the first step, the client (generally a frontend/dapp) sends a signed request to the Xaman wallet by utilizing the Xaman SDK and subscribes for the signed payload response over a WebSocket connection
2. The SDK is a wrapper around the REST API, hence forwards the request to the Xaman backend infrastructure/servers; a QR code is generated and a link to that is returned to the client
3. The client then displays the QR code, who then scans the QR code - which opens the Xaman wallet app
4. The user reviews the transaction details and signs the transaction using the Xaman wallet. The payload and signature are encoded - using the XRPL binary codec (more details below), the result is sent to the server - which then forwards it to the subscribed client
5. The client receives the signed payload and submits it to The Root Network

From Signing to Submission: A Deep Dive into the Integration Flow​

What we want to achieve is to allow users to sign The Root Network transactions using their XRPL based wallet, in this case through Xaman wallet integration. So how would we achieve this?First of all, what is The Root Network transaction?

A Root Network transaction is an extrinsic call that is submitted to the network. The user signs This extrinsic call using their private key via a wallet, where it is validated and executed by the validator(s).

In the case of the Xaman wallet, it cannot directly sign extrinsics; instead, it must sign messages - that too are of a specific format.

The following is a basic payload which the SDK would send to the Xaman wallet for signing:

const created = await xumm.payload?.create({
  txjson: {
    TransactionType: 'SignIn',
  },
  custom_meta: {
    instruction: "Sign Futurepass balance transfer extrinsic",
  },
});

The message/transaction is a special transaction type - SignIn; which is a Xaman wallet app-specific transaction (pseudo transaction). XRPL supports multiple transaction types - but we resort to using SignIn since this is Xaman specific and hence transactions of this type cannot be submitted to the XRPL ledger (since Xaman can also sign XRPL transactions for XRPL chain).

The custom_meta.instruction field is a custom field that is used to specify the instruction to the user - this is displayed in the Xaman wallet app when the user is signing the transaction.

The payload returned by this request looks like the following:

{  
  "AccountTxnID": "...",  
  "SigningPubKey": "...",  
  "TxnSignature": "...",  
  "Account": "rhLmGWkHr59h9ffYgPEAqZnqiQZMGb71yo",
}

• AccountTxnID is a unique identifier for the transaction
• SigningPubKey is the public key of the account that signed the transaction
• TxnSignature is the signature of the transaction
• Account is the derived (from public key) XRPL account that signed the transaction

The basic payload does not have any transaction data, it is a simple sign request. So how can we encode the extrinsic data in the message?By looking at other transactional fields - which can be included in the request, there is an option to include arbitrary data via utilization of the Memos field.This field (Memos) allows for the inclusion of arbitrary hex data in the request - up to a maximum of 1Kb in size.Given this knowledge, we could update the payload to include the extrinsic data in the Memos field like so:

const created = await xumm.payload?.create({
  txjson: {
    TransactionType: "SignIn",
    Memos: [
      {
        Memo: {
          MemoType: stringToHex("extrinsic"),
          MemoData: stringToHex(`${extrinsic.toHex()}`),
        },
      },
    ],
  },
  custom_meta: { instruction: "Sign Futurepass balance transfer extrinsic" },
});

which would produce the following signed response:

{  
  "AccountTxnID": "...",  
  "SigningPubKey": "...",  
  "TxnSignature": "...",  
  "Account": "rhLmGWkHr59h9ffYgPEAqZnqiQZMGb71yo",  
  "Memos": [    
    {      
      "Memo": {        
        "MemoType": "65787472696e736963",        
        "MemoData": "..."      
      }    
    }  
  ]
}

‍It must be noted that this response is encoded in the XRPL binary format. This format is specific to XRPL and is not natively supported on The Root Network. One can say, ok now we have a signed payload, we can submit this to The Root Network as an extrinsic payload. But there is a big problem with this, how do you even wrap this in the extrinsic? Who is the extrinsic signer? and how would the extrinsic be signed? Since we are not using a substrate/Ethereum wallet - if this payload were to be included in a traditional extrinsic we cannot sign extrinsics.

How Can We Support XRPL Transactions on The Root Network?​

The core of EVM transaction support on The Root Network is the SelfContainedCall, a special type of extrinsic call that encapsulates the transaction data and validation parameters within the call itself. It is possible to use the same approach to support XRPL transactions on The Root Network (after making a minor change to frontier's SelfContainedCall trait).

To support this, we would need to expose an entry point for the self contained call - this is where we introduce the new pallet - pallet-xrpl. The self-contained call, i.e. Xaman signed message, must be submitted as an unsigned extrinsic call.

One could imagine the following extrinsic:

pub fn transact(  
  origin: OriginFor<T>,  
  encoded_msg: BoundedVec<u8, T::MaxMessageLength>,
) -> DispatchResult {

The encoded_msg would be the signed XRPL message, which would contain the extrinsic to be executed by the pallet. But before committing to this, we realized the hard limit of 1KB for the memo data. It is possible for large extrinsics, especially batch extrinsics to easily exceed the memo data limit. To address this, we can hash the extrinsic data and include the hash in the memo data field. while including the call to be executed as another parameter in the transact extrinsic above.

This would change the extrinsic to:

pub fn transact(  
  origin: OriginFor<T>,  
  encoded_msg: BoundedVec<u8, T::MaxMessageLength>,  
  call: Box<<T as Config>::RuntimeCall>,
) -> DispatchResult {

Since this is an unsigned extrinsic, it must be validated on-chain. All signed extrinsics (normal extrinsics) are validated via executing signed extensions, these are core extrinsic validators. The signed extensions for The Root Network are:

pub type SignedExtra = (	
  frame_system::CheckNonZeroSender<Runtime>,	
  frame_system::CheckSpecVersion<Runtime>,	
  frame_system::CheckTxVersion<Runtime>,	
  frame_system::CheckGenesis<Runtime>,	
  frame_system::CheckEra<Runtime>,	
  frame_system::CheckNonce<Runtime>,	
  frame_system::CheckWeight<Runtime>,	
  pallet_maintenance_mode::MaintenanceChecker<Runtime>,
  pallet_transaction_payment::ChargeTransactionPayment<Runtime>,
);

We need to perform the same or similar validations for unsigned extrinsics by utilizing the data from the signed XRPL message. This implies that, in addition to the extrinsic hash, we must also include the validation parameters in the memo data. To validate similar unsigned extrinsics, the payload is updated to include the validation parameters in the memo data field.

const created = await xumm.payload?.create({
  txjson: {
    TransactionType: 'SignIn',
    Memos: [
      {
        Memo: {
          MemoType: stringToHex("extrinsic"),
          MemoData: stringToHex(` ${genesisHash}:${nonce}:${maxBlockNumber}:${priorityFee}:${hashedExtrinsic} `),
        },
      },
    ],
  },
  custom_meta: {
    instruction: "Sign Futurepass balance transfer extrinsic",
  },
});

• genesisHash is the genesis hash of the chain so that the same message cannot be replayed on another chain (i.e. a testnet message cannot be replayed on mainnet)
• nonce is the nonce of the account, to ensure that the message is not replayed by the same account
• maxBlockNumber is the maximum block number until the message is valid
• priorityFee is an optional fee that the user can specify to priortize their transaction
• hashedExtrinsic is the hash of the extrinsic call - to be executed within the transact extrinsic

Are We Ready to Submit XRPL Transactions on TRN?​

The response retrieved from the Xaman wallet is different from the JSON shown above (which was decoded for the sake of understanding). The response is encoded in the XRPL binary format. This format is specific to XRPL and is not natively supported on The Root Network. Why is this a problem? Why can we not submit the decoded payload in the unsigned extrinsic?

This is because the signature of the payload (the TxnSignature field) is actually signing the encoded message (as shown in the app source code here). Since we must validate the message on-chain (verify the signature is signed by the signing account/address); the encoded message must be submitted as is - to be decoded and verified against the provided signature on-chain. This was not as simple as it sounds; for 2 main reasons:

• The Root Network protocol code is developed in Rust; there isn't an official Rust SDK to decode XRPL binary messages
• The Root Network protocol code runs in a no_std environment; which means even if we were to find open source rust code to decode XRPL messages, there is a high chance it would not work in a no_std environment

To address this, we had to re-implement the XRPL binary decoding logic in Rust. This was a non-trivial task, as the XRPL binary format is somewhat complex. Rather than implementing the decoding logic from scratch, we decided to first look towards open source solutions; 2 main Rust libraries were found:

• https://github.com/sephynox/xrpl-rust
• https://github.com/gmosx/xrpl-sdk-rust

Supporting ed25519 Signed Transactions​

Now that we can decode the XRPL binary message on-chain, verify the signature against the signed payload and validate the parameters in the memo data against common signed extensions for the self-contained-call; there is still an additional complexity that needs to be addressed.

The Xaman wallet supports multiple signing algorithms - ed25519 and secp256k1. In the initial implementation, we only accounted for secp256k1 signed messages since TRN only supports secp256k1 signatures - because ECDSA accounts (supported by Ethereum and TRN) support the secp256k1 curve.

However, to support any/all Xaman wallet accounts, we must provide support for ed25519 signed messages as well.

To address this, we devised a bespoke solution to generate an Ethereum address from the ed25519 public key:

impl TryFrom<ed25519::Public> for AccountId20 {	
  type Error = &'static str;
  
  fn try_from(public: ed25519::Public) -> Result<Self, Self::Error> {		
    let account =			
      H160(keccak_256(&public.0)[12..].try_into().map_err(|_| "Invalid account id")?);
    Ok(Self(account.0))	
  }
}

and in typescript:

const eoa = Web3.utils.toChecksumAddress(  
  // remove "ED" prefix from public key to compute EOA  
  // keccak hash produces 32 bytes (64 chars) - take last 20 bytes (40 chars)  
  // get last 20 bytes of the keccak hash output (12 bytes = 24 chars; + `0x` = 26 chars)  "0x" + 
  keccak256(hexToU8a(`0x${publicKey.slice(2)}`)).slice(26),
);

Here, similar to how ethereum addresses are generated from the public key, we generate an ethereum address from the ed25519 public key by hashing the ed25519 public key and taking the last 20 bytes. This bespoke solution works for us, and we have incorporated this in our SDKs now. The resulting address from this operation is used to represent an ed25519 signed account on TRN (PR here).

Supporting XRPL Accounts​

With the support for ed25519 signed messages, we can now support all Xaman wallet accounts on The Root Network. Since the Xaman signed message provides the public key of the account that signed the message, we can use the same public key to derive the TRN account (based on public key prefix - ED for ed25519 and 02or 03 for secp256k1). The same public key can also be used to derive the XRPL account addresses as well. To link a Root Network account to the XRPL account, a successful execution of the transact self-contained extrinsic emits an event with the following signature:‍

XRPLExtrinsicExecuted {  
  public_key: XrplPublicKey,  
  caller: T::AccountId,  
  r_address: String,  
  call: <T as pallet::Config>::RuntimeCall,
},

‍Indexers can then listen for this event and map the XRPL account to the TRN account based on the public key.

Looking Further​

As we look ahead into the future, we envision tighter integrations between the XRPL ecosystem (tooling, SDKs, etc.) and The Root Network.

Supporting the Rust XRPL SDK(s)​

During the development of pallet-xrpl we have also made significant contributions to the unofficial Rust XRPL SDK.

We added support for decoding XRPL messages in addition to providing no_std compilation target for the core crates. Both these additions essentially allow any Rust project to decode XRPL messages/transactions on no_std environments, which are commonly on-chain.

As we further integrate with XRP-based tooling, we will likely need to rely more heavily on open-source Rust XRPL SDKs to provide XRPL-specific functionalities. In such cases, we might extend these SDKs or make generic improvements that could be upstreamed to the open-source repositories. These improvements would make Rust ↔ XRPL integrations much easier for future development work by anyone wanting to use Rust for working with XRPL.

First Class Support for Additional XRPL Wallets​

Currently pallet-xrpl only supports messages/transactions signed by the Xaman wallet which specify the special Xaman SignIn pseudo transaction type. To support additional XRP wallets, we’d need to potentially support their respective transaction types or resort to integrating/accepting a more common transaction type (which is not submittable/acceptable by XRPL ledger itself).

Such wallet support would primarily be derived from user demand; which is how we decided to provide support for Xaman wallet in the first place.

The Root Network as an XRPL Compliant RPC​

One potential avenue for exploration is the native support for XRPL transactions on The Root Network. We already have half of the work done - we can decode XRPL binary messages on-chain and verify the signature against the signed payload via utilizing self-contained calls; similar to how Ethereum transactions are supported on The Root Network.

However, we can take this a step further by adding additional RPCs, potentially enabling users to natively transact on The Root Network using XRPL transactions. This would maximise the interoperability between the XRPL and The Root Network ecosystems.

The development journey is far from complete, as we continually strive to design and evolve the pallets to meet requirements and demand.

Learn more about the features and custom pallets The Root Network has to offer here. To stay up-to-date with developments and join our growing community, follow us on X and join our Discord.

The Readyverse features some of the most eagerly anticipated technology developed by Futureverse, and in the trailer, it is showcased with the user’s experience brought to life including the following core components:

AI Curator‍

Personal AI companion to craft and curate your experience.

Surreal Estate‍

Unique user-owned AI-generated personal environments.

Avatars

3D game-ready characters.

Wearables‍

Swappable and tradable wearables and accessories.

Generative AI

Generative AI tools to create 3D objects, environments and music.

The Readyverse is primed to be the definitive destination for fans to explore their favorite stories and IP in the metaverse, leveraging web3, metaverse games and experiences, augmented reality, and virtual reality technologies.

Readyverse Studios is a next-gen metaverse technology and experience studio co-founded by Futureverse Co-Founders Shara Senderoff and Aaron McDonald, as well as Cline and his longtime partner Dan Farah, Ready Player One film producer.

Visit Readyverse Studios for more info and to sign up for early access.

‍

Introducing Root Name Service

Today's the day! Root Name Service (RNS) launches on The Root Network.

Your comprehensive identity solution on The Root Network, encompassing cross-platform, wallet, data, and social identities. RNS simplifies the experience by replacing lengthy wallet addresses with easy-to-remember, human-readable names.

Root Name Service domains allow you to send funds and NFTs to a human-readable name vs. the long string of numbers and characters, like your FuturePass or EOA address.

Turn this: 0x565f137127d9067788314bc7fcc1f36746a3c6Y7

Into this: legend.root

For information on how to secure your Root Name Service identity see their Medium article and FAQs.

Links

Website: rootnameservice.com

X: @RootNameService

Discord: discord.gg/rootnameservice

‍

Overview

Today, Denarii Labs announce the launch of their latest accelerator program, applications are now open for the Futureverse x Denarii Tokenomics Accelerator, backed by Red Beard VC with a $100K investment.

This program aims to support those developing projects on The Root Network and using Futureverse’s modular platform tools.

The 12-week program will focus on comprehensive tokenomic strategy from modelling to investor engagement and is seeking pioneers in, AI, AR, gameFi and socialFi.

Learn more & apply here. Applications close July 8th 2024.

‍

‍

Overview

Reebok, the iconic sports culture brand, today announced the launch of "Reebok Impact" – a custom AI fashion experience on Instagram. Reebok Impact expands the boundaries of sneaker culture by putting new technology into the hands of everyday consumers, allowing the creation of AI-infused, custom digital sneakers.

Sneaker fans globally can immortalize their photo memories in the form of a Reebok digital sneaker by sending it via Instagram DM to @reebokimpact. In a real-time chat, Futureverse's AI will craft a custom sneaker in the colors and style of the image. Users can choose between the iconic Reebok Pump, Classic Leather, or Club C models, and customize the digital sneaker with AI-generated art. From soul to sole; the original photo memory will be stored in the sole of the sneaker, representing the impact of the memory on the soul.

The experience is free for up to 4 digital sneaker creations which you can share or purchase as game ready files compatible with Unreal Editor for Fortnite (UEFN), Roblox and will be interoperable with many virtual experiences to come, including the recently announced upcoming AAA MMO game OPEN, from the creators of Ready Player One.

"We are thrilled to announce the launch of Reebok Impact, which marks an important milestone in our commitment to innovation and technology. We are excited to partner with Futureverse to explore new and engaging ways to bring our brand's ethos to a wider audience. Through Reebok Impact, we look forward to revolutionizing the digital fashion landscape and providing our customers with a unique and immersive experience," said Todd Krinsky, CEO of Reebok.

"We couldn't be prouder to introduce this initial experience as part of our long-term partnership with Reebok. Together we've pushed the boundaries of both personal expression with the exemplification of life imitating art and art imitating life. Leveraging AI creates an easy-to-navigate user experience that meets sneaker fans where they are. The future of fashion has arrived, and this is only the beginning," said Shara Senderoff and Aaron McDonald, Co-Founders of Futureverse.

As the popularity of avatar wearables continues to grow, Reebok and Futureverse have created an innovative roadmap to further bridge the virtual and physical worlds. In addition to designing a commemorative digital sneaker, users can discover an incentive for a sneaker purchase IRL within Reebok Impact.

"Reebok Impact" is the first launch from Futureverse and Reebok, who announced their partnership last year with the intention of creating innovative artificial intelligence, web3, blockchain-based gaming and metaverse experiences for consumers, broadening product interactions across the Reebok ecosystem - powered by Futureverse, built on The Root Network.

For more information and to create your own personal Reebok Impact, visit Reebok Impact on socials: @reebokimpact.

‍

Overview

After launching the Rootscan Block Explorer, the Rootscan team turned their focus to a complementary product tailored for developers. Today, Rootscan API & RPC launch in beta - the ultimate service to help you build on The Root Network more easily, quickly, and effectively.

Just as Infura simplified access to Ethereum with high-availability APIs, Rootscan API & RPC offer seamless access to The Root Network. Their APIs provide real-time data, empowering you to create dynamic and responsive apps.

Rootscan API

Utilize pre-built API endpoints to fetch the latest data from The Root Network in an easily understandable format. Launching with 12 basic endpoints, with plans to expand as the network grows.

Rootscan RPC

Instantly query block data, read transactions, and access network stats through direct RPC endpoints. To ensure stability and performance, nodes run on multiple servers with automatic load balance capabilities.
‍

To let everyone try these services, Rootscan offer free tiers for both API & RPC data streams. If you need higher throughput and more requests, consider exploring paid tiers. For custom requests contact the Rootscan team.

Visit Rootscan for more information.

Overview

We’re excited to integrate with Galxe to bring you a new way to learn, engage and earn ROOT rewards.

Galxe is a leading platform for building web3 community. With over 14 million unique users participating in reward-based loyalty programs. Campaigns are aimed to educate and highlight features of The Root Network, our core developer Futureverse, and experiences built on The Root Network.

Follow The Root Network on Galxe, collect points and earn ROOT rewards.

Overview

Today, Futureverse announced a partnership with CTIA, to support their expansion in Japan, and to help bring Japanese anime IP with its rich culture, heritage and game content to the open metaverse.

CTIA comes with a wealth of expertise in web3, driving innovation, with a strong focus on blockchain and digital transformation. Through a fusion of technology and creativity, they will work closely to provide rich digital experiences shared by fans and creators worldwide.

Aiming to build an open metaverse, where digital collectibles can freely circulate, Futureverse has garnered CTIA’s support as a web3.0 consultant, resonating with its innovative technology. CTIA’s support includes the following:

Acquisition of Globally Renowned Japanese Anime IP & Game Content

CTIA will utilize its expertise and connections in Japan to acquire domestic anime IPs and game content. This initiative aims to create new digital experiences within the open metaverse of Futureverse, utilizing Japanese anime characters.

Expansion of the Japanese Community

CTIA will support the expansion of Futureverse’s community within the open metaverse by engaging Japanese anime fans and creators. This effort aims to promote interaction and new content creation within the metaverse.

Support future development of The Root Network

CTIA will utilize its connections to Japanese game resources as well as web3 developers and builders to expand and deepen the utility of The Root Network for all global market sectors.

Development of brand relationships within globally recognized markets

Through application of Futureverse’s technological innovations, CTIA will interact with Japanese brand names to heighten their visibility globally and broaden their fan bases beyond borders. Market sectors can include manufacturing, agriculture, technology, and sports teams.

CTIA and Futureverse aim to deepen their collaboration, providing a rich digital experience shared by fans and creators worldwide through the fusion of technology and creativity.

Overview

During the design of the native Marketplace Pallet on The Root Network, we overcame many technical challenges and made design decisions that ultimately shaped the Marketplace Pallet you see today. The following article outlines some of these decisions and hopefully, by the end of reading it, you will have a deeper understanding of how the Marketplace, NFT, SFT and related pallets fit into The Root Network runtime. We cover our design processes and share a glimpse of the journey we take as protocol developers when converting features from ideas to reality. If you are interested in reading more, delve into the open-source code here.

Substrate + Pallets

To fully understand the functioning of our Marketplace Pallet, it's helpful to have some background knowledge of Substrate. Essentially, Substrate is a Blockchain framework upon which The Root Network is built. At its core, Substrate is a collection of independent “pallets” each designed to fulfil a specific purpose. The idea is that, if you aim to build a blockchain using Substrate, you can utilize the default pallets provided, which offer basic functionality without requiring extensive custom code. Each pallet is designed to be modular, meaning you may use one but not another for your runtime. While this modular approach is advantageous, Substrate doesn’t provide pallets for every function. And with The Root Network aiming to stay ahead of the game, we have to design and maintain many custom pallets ourselves.

A pallet consists of three main aspects: storage, extrinsics, and events.

• Storage is all of the data stored within a pallet. For example, an account's ownership of a non-fungible token (NFT) is stored on-chain.
• Extrinsics are functions that can be called by a signed account to perform actions on-chain, for example, transfer ownership of an NFT.
• Events are information logs displayed to everyone viewing the chain, indicating that an extrinsic was executed. For example, NFT x was transferred from account y to account z.

At the time of writing, The Root Network has a total of 23 custom pallets that we’ve designed and implemented from scratch for our custom runtime. We will focus on three key pallets in this document: Marketplace, NFT, and SFT.

Non Fungible Origins

Now that you understand more about pallets, and how they serve as the fundamental building blocks of The Root Network, let’s delve deeper into one of those custom pallets: the NFT Pallet. As you may know, Non-Fungible Tokens (NFT) are unique, digital assets that reside securely on the blockchain. On Ethereum, NFTs are a token_id contained within ERC-721 Smart Contracts (or similar), each containing unique data per contract. ERC-721 serves as a token standard used to provide some cohesion between these NFT contracts.

There's a significant difference between Ethereum and The Root Network regarding NFTs.  Ethereum “technically” doesn’t have any conceptual knowledge of what an NFT actually is. Instead, it just allows people to write and deploy contracts that provide the behaviour of what we know as an NFT. These contracts enable actions such as minting, transferring, burning and other expected NFT operations. However, it’s the contract itself that defines this logic, rather than the network. In contrast, The Root Network aims to provide a more standardized level of NFT logic. This is achieved by defining the logic of an NFT at the protocol level and providing common interfaces that can be easily utilized by anyone to use and interact with this logic. This means, to deploy a collection on The Root Network you don’t need to write a single line of code, just call create_collection on the NFT Pallet and you can be the proud owner of an NFT collection at a fraction of the cost.

We talk about how the NFT Pallet holds the “logic” of an NFT within itself, but what does this actually mean? It acts as a portal with a set of rules to interact with a set of data, common across all NFT collections. This data will be different between collections, however each collection will behave identically. For example, to determine ownership of a token, each collection has a token_ownership map which is a list of serial numbers within the collection owned by a particular address.

Protocol-level logic greatly benefits the standard user, however, it comes with its own set of challenges. How do you design a system for everyone? Designing pallets, like the NFT Pallet or the Marketplace Pallet, requires the designer to see into the future. It’s nearly impossible to know what use cases will come along and in which way the limitations will be stretched. However, one of the biggest advantages of housing the logic in the runtime (as opposed to a Solidity contract) is that it can be expanded upon, given it’s designed in such a way that allows for expandability.

The History Of The Marketplace

In the first iteration of the Marketplace Pallet on The Root Network, the entirety of the Marketplace Pallet’s functionality was encapsulated within the NFT Pallet. This meant there was only one pallet responsible for tasks such as minting, transferring, buying, and selling NFTs. While this approach initially worked well, with SFTs on the horizon and the ever-growing complexity of the marketplace component, a change was necessary. One pallet was simply too stretched to adequately contain both the NFT and marketplace functionality. Therefore, it was logical to split the pallet into two distinct components. One would be primarily focused on NFT-related tasks, including minting, creating collections, transferring, and burning. Another (the newly appointed Marketplace Pallet) would focus on functionalities such as buying, selling, auctions and offers.

This sounds great in theory, but dividing a pallet in half comes with many complexities. The biggest and riskiest part is transferring the storage from the NFT Pallet to the new Marketplace Pallet and continuing operations from where we left off. This process is called Runtime Storage Migrations, and I like to think of it as replacing the tire of a moving car. Or in this case, splitting the tire into two pieces and installing an entirely new wheel.

Storage migrations are a particularly sensitive aspect of updating the runtime as each migration runs the risk of corrupting data. If this happens, the best case scenario is that people lose their NFTs and any value associated with them, the worst case scenario is that The Root Network becomes bricked and completely inaccessible. Despite implementing numerous procedures to test migrations against copies of the chain’s state before operating, it’s still a part of this job that causes the heart to skip a few beats when we perform the upgrade.

Another consideration when implementing significant changes like this is how it impacts any external teams building on the network. Imagine developing a frontend for a marketplace, only to find the pallet you were interacting with has split its functionality and moved to a different pallet. This is why communication regarding our changes and their potential impact on any external teams affected is crucial.

The Rise Of The Semi-Fungible Token

Now you have an understanding of the structure of Substrate and some of the complications of how we got to this point. The Marketplace and NFT Pallets are now two separate components, working together to provide a service to those who use them. But what if we introduced a new token standard?

Enter SFTs. Designed as a native The Root Network solution to the ERC-1155 token standard on Ethereum, SFTs entered The Root Network to completely shake up the relationship between NFTs and the Marketplace. The reason for SFT support is to create a token standard with strong gamification purposes, think in-game items or partially unique collectibles. To understand the differences between NFTs and SFTs it’s best to look at an example.

For NFTs, each token_id is represented by a collection_id and a serial_number as follows:

NFT_token_id = (1124, 4)

This represents token 4 from collection 1124. It is impossible to have two NFTs with the same token_id, however, you can have multiple unique tokens within the same collection

i.e.‍

(1124, 0)
(1124, 1)
(1124, 100)

‍The above tokens are all from the same collection however, they are unique due to their unique serial_numbers.

For SFTs, this is similar in that each token is represented by (collection_id, serial_number) but it is possible to own more than one of the same token, or multiple people can own a copy of the same token_id.

For example,‍

Bob owns 5 of (2534, 5)
Jason owns 100 of (2534, 6)

‍This seemingly simple difference means that an entirely new data structure must be designed to accommodate SFT ownership.

That’s where the SFT Pallet comes into play. Although fundamentally it seems very similar to the NFT Pallet, internally the moving pieces move in a very different way.

One Marketplace for All Tokens

The Root Network is growing rapidly, new pallets left and right supporting all types of token standards. SFTs, NFTs and Assets are increasing and more collections are being bridged/minted on The Root Network. This is an exciting time, but we are missing a piece to this complicated puzzle, SFT marketplace support. Why own an SFT if you can’t trade it? This is where our work before becomes extremely valuable, by separating the Marketplace code from the NFT Pallet, we open up the possibility to expand the Marketplace Pallet to support not only NFTs but also SFTs.

This is great in theory, however it is not as simple as it sounds. Due to the differences in the way NFTs and SFTs are stored on-chain, a different interface is required to sell these tokens. Currently selling an NFT looks like this:‍

pub fn sell_nft(
	origin: OriginFor<T>,
	collection_id: CollectionUuid,
	serial_numbers: Vec<SerialNumber>,
	buyer: Option<T::AccountId>,
	payment_asset: AssetId,
	fixed_price: Balance,
	duration: Option<T::BlockNumber>,
	marketplace_id: Option<MarketplaceId>,
)

‍You can see from the above interface that we can specify a collection and then specify multiple serial numbers within that collection, these are the NFTs that will be included within the marketplace listing. So you could sell tokens (1124, 5) and (1124, 6) in one listing.

But for SFTs, we may want to sell a quantity of a certain token, e.g. 5 x (1124, 5) so the interface would look something like this:

pub fn sell_sft(
	origin: OriginFor<T>,
	collection_id: CollectionUuid,
	serial_numbers: Vec<(SerialNumber, Balance)>,
	...
)

‍Separating the sell extrinsic into two parts, one for SFT and one for NFT would work in theory, however, it is a messy approach that doesn’t allow for any expansion in the future. Due to this, we ended up changing the interface to be generic across multiple types of tokens, either SFT or NFT, with room to grow in the future. The interface for that looks like this:‍

pub fn sell(
	origin: OriginFor<T>,
	tokens: ListingTokens<T>,
	buyer: Option<T::AccountId>,
	payment_asset: AssetId,
	fixed_price: Balance,
	duration: Option<T::BlockNumber>,
	marketplace_id: Option<MarketplaceId>,
)

‍Where listing tokens is an enum that looks like this:‍

/// The type of tokens included in a marketplace listing, used to specify the type of listing
pub enum ListingTokens {
	Nft(NftListing),
	Sft(SftListing),
}

// A group of NFT serial numbers from the same collection
pub struct NftListing {
	pub collection_id: CollectionUuid,
	pub serial_numbers: Vec<SerialNumber>,
}

// A group of SFT serial numbers and balances from the same collection
pub struct SftListing {
	pub collection_id: CollectionUuid,
	pub serial_numbers: Vec<(SerialNumber, Balance)>,
}

‍That way, we can create one interface to rule them all! This also allows us to do some clever tricks where we can implement some common functionality over ListingTokens that can be uniquely handled for each case. i.e. if we want to lock the tokens (an important step when creating a listing to prevent the owner from transferring the tokens while the listing is active) we can do this:‍

/// Locks a group of tokens before listing for sale
/// Throws an error if owner does not own all tokens
pub fn lock_tokens(&self, owner: &T::AccountId, listing_id: ListingId) -> DispatchResult {
	match self {
		ListingTokens::Nft(nfts) =>
			for serial_number in nfts.serial_numbers.iter() {
				let token_id = (nfts.collection_id, *serial_number);
				T::NFTExt::set_token_lock(
					token_id,
					TokenLockReason::Listed(listing_id),
					*owner,
				)?;
			},
		ListingTokens::Sft(sfts) =>
			for (serial_number, balance) in sfts.serial_numbers.iter() {
				let token_id = (sfts.collection_id, *serial_number);
				T::SFTExt::reserve_balance(token_id, *balance, owner)?;
			},
	}
	Ok(())
} 

‍Then we just need to call this by using listing_tokens.lock_tokens(…) You can see that we end up with quite a clean, robust interface that not only allows us to have one extrinsic for both NFTs and SFTs but keeps the internal code clean and expandable within the Marketplace Pallet.

This system also allows us to expand upon the marketplace in the future and introduce new token standards without breaking the existing interface. We simply need to expand the enum to include the new token standard and implement its required behavioural patterns.

Dividing The Fungible Pie

Due to the value of NFTs and SFTs, we need a way to manage and share royalties. Let’s look back at Ethereum for an example, on OpenSea when you sell an NFT, you don’t receive 100% of the sale price. A small percentage of all sales within a collection are automatically transferred from the buyer to the creator of the collection, as well as a smaller cut to OpenSea themselves.

On The Root Network, we call this a RoyaltiesSchedule. The creator of any SFT or NFT collection can list up to 6 accounts and their percentage of royalties when creating the collection. Then anytime anybody sells one of those tokens, the network automatically distributes the royalties to the correct parties.

It doesn’t end there though, a marketplace can register itself as a marketplace on the network, and provide its unique MarketplaceId to add its cut to the royalties schedule of tokens sold on its site.

On top of that, 0.5% of every sale is automatically sent to our network's “FeePot” address. This forms part of the unique tokenomics of The Root Network and feeds the rewards pool for those securing the network through the vortex-distribution pallet.

And finally, the majority share will be sent to the seller of the token and the transfer will be initiated. There is no real limit to the royalties set by the marketplace and the collection owner. Theoretically, they could take 90% of all tokens, but who would want to buy a token where the owner takes 90%?

It’s worth noting, a collection owner can change their royalties entitlement at any time (unless they revoke ownership of the collection). However, a marketplace cannot change their royalties entitlement once registered.

Limitations and Restrictions

The unfortunate reality of designing any new pallet is that there will never be a perfect solution to accommodate everyone's needs and requirements. The perfect solution that appears in our dreams might be clouded by technical limitations or time constraints. Although we always have a core set of requirements that must be met, certain features may not make the final cut and we may have to introduce additional constraints to deliver the solution within the time frame.

For the Marketplace Pallet, a limitation that has existed throughout its lifetime is that a marketplace listing can only contain tokens from one collection. You may sell multiple tokens from the same collection in one listing, however, more than one collection has been intentionally restricted. The reason for this is due to the way royalties are paid out at a sales close. Just like on popular marketplaces such as OpenSea, The Root Network Marketplace Pallet supports sale royalties that are paid out to the collection owner at the time of sale. i.e. 5% of the sale price will be sent to the collection owner. The collection owner has the ability to specify different royalties on a collection-wide basis. This means that if you sell 5 NFTs or SFTs from one collection for 100 ROOT, 5 ROOT would go to the collection owner.

Now imagine the listing contains NFTs from multiple different collections. It would be easy to split the royalties if each collection owner took the same amount of royalties (i.e. 10% of the sale price) in this scenario we could easily distribute that 10% amongst the individual collections. e.g. if tokens from 5 collections were included in the bundle, each collection would receive 2%.

However, this will not work as we may have one collection with 10%, one with 15%, one with 5% etc.

If we were to estimate the royalty percentage based purely on the total sell price, there would be situations where some collection owners do not receive the royalties they deserve for the bundle sale. (i.e. if the value of their token made up 90% of the bundle price but they only receive 30% of the royalties).

Our preferred way to distribute royalties amongst the different collections would be to distribute based on the perceived value of each item within the bundle, this is not possible to do node side however, as we have no way to retrieve the value of an NFT besides what the user inputs as the sale price.

One way to achieve this would be to input the value of each token within the bundle when listing that token for sale, rather than one flat fee for the whole bundle. Then we can internally calculate the total bundle price from each price, distributing the royalties accordingly. This first step can become complicated and will be the responsibility of the marketplace to allow a user to enter these values.

With ERC-721 collections, such as FLUF World, the value of the FLUF NFT is determined by each individual trait in the tokens metadata. On OpenSea the floor price for each trait is displayed which allows users to easily see roughly what their FLUF is worth at that time.

The marketplace could implement a similar system to ensure their users are selling the items in the bundle at the appropriate price while still giving the collection owners their fair share of royalties.

Interesting Problems With Interesting Solutions

Sometimes when designing features you encounter problems that are not immediately obvious. One of these problems has to do with optimization, causing a butterfly effect of problems. In Substrate, you can store any type of data, strings, integers, custom structs etc. For NFT collections we store royalties for a collection which contains a list of entitlements. i.e. you can setup your collection to payout a percentage of each sale to multiple accounts automatically. Due to the nature of the blockchain, we can’t store infinitely large lists of data so we use a storage type called a BoundedVec for arrays. This is essentially a list of items with an upper bound to length. For royalties, the upper bound is set quite low (6 different accounts max). This works well, however, this doesn’t take into account a strange edge case within the Marketplace Pallet that adds two items to this list, potentially sending it over the upper limit of the bound, and causing the listing to fail.

Say a collection is created with the upper limit of 6 total entitlements. When we create a listing, there is the possibility the marketplace also collects royalties (marketplace royalties). We also have a network fee of 0.5% which is used in the same context. Meaning, when a listing is created, both the marketplace royalties and network fees get appended to the entitlements of the collection which will push it past the upper bound of the BoundedVec type. If this happens the listing will fail, rendering all NFTs within this collection unsellable.

Obviously, this is not ideal as it is unclear to the owner of the NFT why their token failed to sell which leads to a poor user experience.

The solution was relatively simple for this example, we increased the bound of the storage item within Substrate to 8, then when creating the collection or updating the royalties, we simply checked that it was less than the original bound of 6. That way there will always be room for the network fee and marketplace royalties when the token is listed for sale.

What’s Next for NFTs, SFTs, And The Marketplace Pallet?

Although we’ve covered the current state of the three pallets, their journey in the exciting world of The Root Network runtime is far from complete. Much like every moving part in The Root Network, requirements change, code can be optimized and features can be developed to extend the existing framework.

For SFTs that comes in the form of supporting bridging to and from Ethereum (much like it’s NFT big brother). For the Marketplace Pallet, the future is even more exciting and includes a robust system for both NFTs and SFTs (currently only NFTs are supported) and the potential for buying and selling bundles of both NFTs and SFTs from different collections.

Although it’s impossible to see the future, we can do our best to design the pallets in a way that allows for easy expansion when needed.

Learn about more features and custom pallets The Root Network has to offer here. To stay up-to-date with developments and join our growing community, follow us on X and join our Discord.

Overview

Catalyze Research, a consulting company specializing in blockchain and web3, announced today the creation of the $10M ‘Catalyze Futureverse Ecosystem Fund’ with Born Ready Ventures.

The Catalyze Futureverse Ecosystem Fund plans to invest in startups exploring new possibilities in the fields of web3, metaverse, and Artificial Intelligence (AI). Accelerating startups in the development of the open metaverse, built on The Root Network and supported by Futureverse.

Poised to drive exponential growth on The Root Network, this collaboration will unlock opportunities for startups across the Asia-Pacific (APAC) region, with a primary focus on Korea.

Since 2017, Catalyze has been investing in leading projects such as Matic Network (now Polygon), Biconomy, and Numbers Protocol. They also support ventures spanning metaverse, gaming, and web3, by providing expertise in GTM strategy, marketing, and business development.

Catalyze and Born Ready will harness their expertise to identify and invest in promising startups while providing comprehensive strategic growth support.

"We're excited to partner with Catalyze on the Catalyze Futureverse Ecosystem Fund to accelerate startups building on The Root Network in the Asia-Pacific region. Together, we'll continue shape our digital future," Aaron McDonald and Shara Senderoff, Co-Founders of Born Ready.

Learn more here.

Overview

Born Ready Ventures leads BoF's pre-seed round to support the rollout of BoF's RWA B2B Infrastructure and B2C Platform on The Root Network, which incorporates technology by Immersve.

BoF is building the next generation of RWA infrastructure, enabling both Retail and Institutional users to seamlessly access Real-World Assets with no minimum deposit. Users will be able to effortlessly transfer funds between various RWA Earn Accounts and a Spending Account linked to a BoF Mastercard powered by Immersve.

One moment users can be earning yield on their USDC through US Treasury Bonds that are backed 1:1 with the underlying asset; the next, they can seamlessly transfer that USDC to their Spending Account to spend anywhere Mastercard is accepted globally. The BoF Mastercard also supports Google and Apple Pay and will be rolled out in sync with Immersve's jurisdictional and technical launch program.

BoF's RWA Infrastructure is being developed not only to serve our B2C platform but also to be offered to B2B customers who wish to provide RWAs through their own platforms on any EVM compatible chain.

Stay tuned for more updates as they move towards launching on The Root Network in the coming months, including an exciting activation in partnership with Futureverse.

For more information about BoF please visit their website and sign up to receive important launch updates and news.

Overview

The Root Network comes with pre-built pallets that make fungible asset management easy and intuitive, highly optimized for efficiency and stable transaction fees. Additionally, fungible assets on The Root Network are ERC-20 compatible, once created they are tradable on both native and EVM layers.

The following guide will walk you through how to create, mint, and manage a fungible asset using The Root Network Portal.

Requirements

• An account with 100 ROOT to reserve the asset in the chain storage and at least 0.1 XRP for initial asset creation.

‍

Overview

The Third Kingdom is an upcoming strategy simulation game announced today, powered by Futureverse in partnership with Walker World and built on The Root Network. Embark on a journey across The Third Kingdom as you cultivate resources in your very own corner of this abundant realm.

The Story

A cataclysmic event, The Wreck, has torn apart the Mycelium Network of The Third Kingdom, plunging countless worlds into decay. The Great Tree is fading, casting a shadow of doom across the land and all its inhabitants. Amidst the chaos, malevolent forces sense the vulnerability of this once-flourishing kingdom, invading with UFOs, Ooze-powered lasers, and sinister plans to shape it into one of their own. As the Ooze permeates the atmosphere, spoiling the already-decaying land, the fate of The Third Kingdom lingers in uncertainty.

The citizens of The Third Kingdom are faced with a dire choice: perish at the hands of the evil that looms, or band together to reclaim their treasured homeland.

A desperate plea echoes out across the metaverse to valiant individuals and the courageous at heart. Armed with Prysms, they must venture into the uncharted wilderness to restore the world around them and return The Third Kingdom to its former glory.

Will you answer the call?

The Game

Prepare to enter The Third Kingdom, an upcoming strategy simulation game, powered by Futureverse in partnership with Walker World.

The Third Kingdom invites you to lay your claim to an evolving digital realm, and the abundant rewards to follow. There is up to 312,500,000 ROOT in total waiting to be unlocked in the first season of The Third Kingdom alone, with its discovery at the hands of players.

You’ll embark on an unfolding journey across SurrealScapes, your own slice of The Third Kingdom. Equipped with harvesting devices called Prysms, you’ll develop your domain, manage and refine resources like Mycelium, discover new islands, and forge your production empire.

SurrealScapes

SurrealScapes are a collection of resource-rich biomes, and your very own slice of The Third Kingdom.

Each SurrealScape is comprised of 1, 4, 9 or 16 parcels. Rich with resources, each SurrealScape you own can be farmed using Prysms, harvesting devices that source and extract valuable in-game resources. Install up to 3 Prysms on each SurrealScapes parcel to maximize your resource-harvesting potential.

Ready to stake your claim to the kingdom? SurrealScapes in Season 1 of The Third Kingdom will be exclusively gifted to eligible holders within the following collections: FLUF World,

SurrealScapes will be gifted to eligible holders on release and tradable on The Root Network marketplaces. Community Land will also be open in-game, allowing all holders of Prysms to participate in the harvesting experience (see Community Land below).

For Burrows holders, the FLUF World Scenes you hold in your wallet matter, and have made an impact on the SurrealScapes you will receive. In addition, your Burrows metaspace has been upgraded and will be featured as a premium and customizable environment in an upcoming Readyverse experience. Stay tuned!

Prysms: Your Keys To The Kingdom

Prysms are your key to accessing The Third Kingdom game, and unearthing the treasures within SurrealScapes.

Prysms will be available exclusively through an upcoming Fair Value sale, open to all, featuring a novel protocol developed by Ottó Blockchain and powered by The Root Network Crowdsale Pallet. Participants will be invited to purchase premium Prysms with ROOT in this sale. More details of the sale are available in their blog post: The Third Kingdom: Prysm Sale.

Each Prysm purchased in this sale will be premium, boasting superior trait advantages in The Third Kingdom game. The total supply of these Prysms in Season 1 of The Third Kingdom is 135,000, with fewer premium Prysms in existence than can be placed on land slots in the SurrealScapes collection. The Fair Value sale is not to be missed.

Prysms feature a prefix and suffix trait, mapping each to an in-game biome and industry. Installing these on your SurrealScapes parcels will begin a unique and strategic harvesting experience, shaped by the number of Prysms you are using, the traits they possess, and their synergy between SurrealScapes biomes and resources contained within.

Whether you own SurrealScapes or not, Prysms are a must-have collectible, providing access to The Third Kingdom game and ongoing rewards. Ready to secure yours?

Community Land

While SurrealScapes holders enjoy a significant advantage and greater rewards in The Third Kingdom game, those without will be able to participate by planting Prysms on Community Land.

Community Land in The Third Kingdom game is a shared space, through which eager harvesters without a SurrealScape in their wallet can participate in gameplay for a chance of ROOT rewards. Secure Prysms to unlock access to the experience.

Futureverse Rewards

Both SurrealScapes and Prysms will contribute to a player's FutureScore. While Prysms are consumable items that become untradeable once used in-game, the associated FutureScore will be permanently retained. This score is a reflection of your active role in the Futureverse ecosystem and is your key to earning ROOT through the FutureScore Quest program.

In addition, there will be a Future Quest and Engagement Score bonuses for participating in the Prysm sale. Stay tuned for details on the upcoming quest for the Prysms release. If you don't already have a FuturePass, set one up to prepare for your FutureScore today!

The Open Metaverse

The Third Kingdom will be setting the stage to release the Material World protocol, a game catalogue protocol designed and developed by Futureverse. The Material World API system enables users to collect, refine, craft and distribute in-game resources and offers creators the opportunity to access and share the thriving interoperable economy in game experiences, driving value back to its players.

Your Kingdom Awaits

The Third Kingdom is an exciting new gateway to interactivity, interoperability, and a rewards-harvesting journey like no other. Follow them on X and Discord for the latest updates to ensure you don’t miss a beat. See you in the kingdom.

Earlier this year, Readyverse Studios—established through a collaboration between blockchain tech company Futureverse and Ernest Cline, the creator behind the sci-fi sensation Ready Player One—revealed "The Readyverse." This innovative platform aims to offer immersive metaverse games and experiences. In partnership with Warner Bros. Discovery (WBD), the studio is set to bring the beloved novel into the web3 metaverse.

Today, Readyverse Studios has unveiled its inaugural project, which will soon debut within The Readyverse—OPEN.

OPEN’s immersive multiverse will feature nostalgia-infused biomes with characters and cultural legends across iconic franchises. Challengers embark on game-show styled, multi-round collaborative and competitive game modes, but only one hero can emerge victorious.

Showcasing a variety of gaming disciplines with tactical positioning, sly movement, strategic shooting, and driving skills taking center stage. Collaborate with allies, strategize for advantages, and immerse yourself in intense gameplay sessions.

Among additional globally recognized IP, such as Reebok and Delorean Motor Company featured in the teaser, OPEN will feature a Ready Player One biome where fans can engage in competitive experiences born from the novel and film itself; including branded environments and skins.

“Joining forces with Walker Labs team of seasoned game devs from Epic, DICE, Microsoft, PlayStation, Remedy, EA, and more, has allowed us to tackle the genre-defining challenge of building a AAA, MMO open metaverse experience worthy of iconic IP” said Readyverse Studios Co-Founders.

“As avid fans of the IP entering OPEN, especially Ready Player One which came to define the open metaverse for mainstream consumers, we're busy crafting a memorable lore, in close collaboration with Ernest Cline, where players can immerse themselves for years to come,” said Wajhi Jafri, EP.

OPEN is now in development for PC and current-generation platforms.

Sign up for early access here.

‍

Overview

As AI takes center stage, Altered State Machine (ASM) is even more relevant today than it was when their journey began 5 years ago. In Futureverse’s new paper, Evolving ASM: The Metaverse AI Protocol they unveil the evolution of ASM on The Root Network.

The rise of LLMs has redefined how consumers engage with digital intelligence, igniting an explosion of use cases that have allowed the hype of AI to overpower the narrative of the metaverse. But, we believe they are interconnected facets of the same transformative coin.

ASM foresaw the crucial intersection of AI & web3 and designed the ASM Protocol to meet this massive opportunity, wherein an immersive web landscape would give way to the pervasive presence of AI agents and digital twins would revolutionize user experiences. ASM’s core vision remains unchanged amidst the industry’s swift progress. As AI shapes our future, the ASM Protocol's value proposition—ownership, interoperability, and composability—only grows stronger.

Futureverse has integrated ASM with 10 other companies, combining expertise and research across all aspects of the metaverse: identity, social graphs, core blockchain, 3D pipelines, gaming, generative AI, and more, to create one super team. Their domain expertise across this diverse range of fields, and their intricate intersections, is, we believe, unparalleled in web3. Futureverse possesses a unique perspective on the requirements to construct a comprehensive vision for AI in the spatial internet.

Introducing The Murmur Matrix

Today, Futureverse and ASM reveal The Murmur Matrix as the focal point of their vision for spatial intelligence. The Murmur Matrix is a revolutionary system that empowers AI to comprehend 3D objects, avatars, and spaces.

The Murmur Matrix facilitates the storage of events and interactions in 3D environments as long-term contextual memories that can propagate through contact, fostering shared consensus around knowledge and activities. It plays a pivotal role in enabling AI agents to seamlessly operate across diverse metaverse environments, ensuring a sense of unified intelligence and delivering interoperability. It enhances the realism and contextual awareness of NPCs.

B.R.A.I.N.S

ASM 2.0 details a significant evolution of their B.R.A.I.N. concept. This advancement includes merging The Murmur Matrix with the Genome Matrix to incorporate emotional context, and introduce personality elements to complement the existing Skills Matrix. A B.R.A.I.N. has become a universally understandable data container for LLMs, AI models, or game engines. Your avatar transcends its visual representation to become a memory, or e.g., a digital shoe becomes an intelligent wearable, capable of storing skills and experiences.

Dynamic Object Creator

They also revealed DOC (Dynamic Object Creator), their cutting-edge patent-pending 2D, 3D, and environmental generative model, designed to produce high-quality, game-ready 3D content for the open metaverse.

DOC seamlessly integrates with Futureverse's patent-pending content interoperability standard, UBF (Universal Blueprint Framework). Paired with UBF, and enhanced by their powerful generative sound and music AI, DOC can bring any imagined world to life.

AI meets Ownership and Interoperability

They detail how the values of ownership, interoperability, and composability are facilitated by The Root Network’s core infrastructure protocols, along with Sylo, demonstrating the seamless connection to our core data protocols, including the Asset Register.

Through the collaborative knowledge and domain expertise of Futureverse, they've strategically aligned Altered State Machine, Sylo and The Root Network to amplify and expand the role of AI in their vision for the open metaverse.

Dive into the full vision paper for intricate details on the expansion of Altered State Machine—the heart of the open metaverse—on The Root Network.

‍

Overview

The Root Network is gearing up for open beta, expanding validator slots for new participants and developers!

As part of this work, network fees have been reduced by 67%, empowering devs to build scalable applications with confidence. Our Bootstrap rewards remain in place to ensure strong incentives for validators as network traffic grows.

The number of validation seats will increase to 42 on February 20 UTC, with new validators being elected within the 48 hours following.

Validators are node operators and an essential part of the Proof-of-Stake consensus mechanism. On The Root Network, validator nodes are responsible for authoring new blocks and participating in the finalization protocol.

If you’re interested in becoming a validator we recommend you read our documentation for requirements, instructions, and the election process.

Become a Validator

Validators are node operators, each storing a copy of the blockchain and performing certain functions to keep the system secure. On The Root Network, validator nodes are responsible for authoring new blocks and participating in the finalization protocol.

Running a validator on a live network is a high-risk, high-reward opportunity. You will be accountable for not only your own stake, but also the stake of your current nominators. If a mistake occurs and your node gets slashed, your tokens and your reputation will be at risk. However, running a validator can also be very rewarding, knowing that you contribute to the security of a decentralized network while growing your rewards.

It is highly recommended that you have significant system administration experience before attempting to run your own validator. You must be able to handle technical issues and anomalies with your node which you must be able to tackle yourself. Being a validator involves more than just executing the The Root Network binary; it requires a comprehensive understanding of system administration to effectively navigate and troubleshoot various challenges.

See our documentation for requirements, instructions, and the election process.

Validator Rewards

The Root Network has unique features that differentiate its tokenomics from other blockchains. Specifically: The Root Network is an any-token gas blockchain to simplify user onboarding. Currently, users can transact in XRP, ROOT, A, and. As a result, no single token is used for gas and network fees.

Validators or delegators who stake ROOT will earn fees from various network activities to ensure there is sufficient incentive to operate a node and stake. The block rewards for staking can come in several forms.

• Gas spent in the network is distributed to block producers—the default Gas token.
• XRP provides validators with instant real value for producing blocks.
• Initial bootstrap pool: 10% of the ROOT tokens will be distributed to block validators and stakers over the first 260 weeks.
• Fees generated by the various network runtime activities. Including:
  • NFT trading fees from the Non-fungible Asset runtime
  • Token minting fees in the Fungible Asset runtime
  • Trading fees for the DEX and the Gas Fee Exchange

A high-level overview

• Gas and network fees accumulate during the reward cycle (90 days).
• These fees are transferred into The Vortex at the end of the cycle, and Vortex tokens are minted to reward participants based on their participation level.
• Participation level is based on two things:
  1. The amount and duration of ROOT staked, and
  2. The work done as a validator, measured in Work points
• Vortex tokens can be redeemed anytime, releasing the underlying tokens in The Vortex to the holder.

How are rewards distributed?

All rewards on The Root Network are distributed as Vortex tokens. Vortex tokens are tokens that can be redeemed to release a corresponding percentage of tokens that are in The Vortex.

Two types of rewards contribute to The Vortex each reward cycle: Bootstrap Rewards and Gas and network fees.

Bootstrap rewards

• Bootstrap rewards account for 10% of the total supply of ROOT tokens over 260 weeks to early backers and supporters.
• This is distributed based on staked ROOT tokens by duration in the reward cycle.
• At the end of the reward cycle, The Root Network calculates the Bootstrap Reward for each participant type, transfers it into the Vortex, mints Vortex tokens, and distributes them to participants.

Rewards from gas and network fees

• This reward pool is based on gas and network fees collected. At the end of the reward cycle, these fees are used to mint Vortex tokens to reward participants.
• 30% of these Vortex tokens are distributed to stakers, nominators and validators. The distribution is based on the amount and duration of their staked ROOT relative to the total ROOT staked and its duration by all participants.
• The remaining 70% are distributed to validators and nominators based on their proportional Work points earned throughout the reward cycle.

How are the Vortex token mints calculated?

At the end of each reward cycle, the protocol determines the value of the tokens added to the Vortex. It also divides the value of The Vortex itself by the number of Vortex tokens in circulation. These numbers are used to calculate the amount of new Vortex tokens to mint and distribute as rewards to participants.

What are Work points? And how do they work?

• Work points are earned by validators for doing work to complete blocks and transactions on the network.
• As a nominator, you earn a percentage commission of Work points your selected validators earn.
• At the end of each Era (24 hours), you will see an estimate of your Work points on the staking dashboard.
• Work points do not directly translate to Vortex tokens.

If you’re interested in becoming a validator we recommend you read our documentation for requirements, instructions, and the election process.

Overview

We are thrilled to introduce Rootscan, new block explorer for The Root Network. The team at SanctumAI Labs, backed by Born Ready VC, is committed to developing essential infrastructure for the Futureverse and Root Network ecosystems.

Their focus has been on creating a faster node network and API for The Root Network, aimed at both end users and enterprises, similar to Ethereum's Infura. Rootscan showcases their infrastructure's capabilities in speed and data delivery, making data more accessible for The Root Network users.

Data and API Services

Rootscan are launching their data and API services for developers, simplifying the process for those who prefer not to manage their own infrastructure. As the network expands, managing assets and transactions will become increasingly complex for app and dApp teams.

Rootscan serves as the interface for their services, with Rootscan API (rsAPI) as the engine. They aim to collaborate with the community to enhance Rootscan while developing their API offerings, ensuring financial sustainability without intrusive advertisements.

Explore Rootscan

‍

Overview

Outlier Ventures and Futureverse have unveiled the first cohort of the Futureverse Base Camp accelerator program, selecting seven startups from ~500 applicants. These startups are dedicated to advancing the open metaverse, focusing on scalable and interoperable apps, as well as AI, games and experiences.

Meet the First Cohort

Intraverse

Intraverse is a Gaming As a Service platform that offers to NFT Projects, IPs, Brands, and Games user acquisition, engagement and retention thanks to cross-community gamified experiences.

Lifelike Digital

Lifelike Digital develops realistic digital humans for seamless integration across the metaverse. Their AI-powered avatars have rich characters, exhibit natural behaviors, and provide immersive interactions.

MintPass

MintPass is a platform for travelers to authenticate their activities with mobile geolocation data to generate and share NFT digital souvenirs that showcase where they’ve been and what they did while there.

Plurality

Plurality lets users create personalized Web3 accounts through easy onboarding and the option to connect their plural personas from existing social profiles.

REKT Interactive

REKT Interactive is an on-chain oracle and platform for developers to build custom wagering markets. It processes real-world digitalized datasets and generates competitions requiring a wager using ML tech.

Spark

Spark integrates with products and services from crypto and TradFi, providing powerful workflow functionality through a unified interface.

Nucanon

Nucanon exists to democratize game design and make the creative process of building expansive game worlds accessible to more people.

Futureverse Base Camp: Accelerating the Open Metaverse

Aaron McDonald and Shara Senderoff, Co-Founders of Futureverse and Born Ready, expressed their excitement about welcoming the inaugural cohort of builders into their strategic ecosystem. They emphasized their commitment to pushing the boundaries in the space, believing in a collective vision for the future of the internet that relies on the innovative ideas of many visionaries.

"We're thrilled to support and back the teams paving the way for technologies and ideas that will drive the development of the open metaverse and web3 landscape." Aaron McDonald & Shara Senderoff, Co-Founders of Futureverse & Born Ready

Blake Lezenski, Partner Program Director at Outlier Ventures, echoed this enthusiasm, stating, "We are thrilled to announce our first cohort with Futureverse and share the details of the incredible teams who have been carefully chosen to join the program."

"We had a huge amount of interest in the program with close to 500 applications, highlighting the momentum behind Futureverse, the aptitude of open metaverse technology builders as well as their infrastructure and rich IP ecosystem around The Root Network. As long-running partners from the early stages of working with multiple layers of their ecosystem, we are now excited to kick off our program and work together to support the founders who will define the future of the open metaverse.” Blake Lezenski, Partner Program Director at Outlier Ventures.

Selected Startups to Benefit from Expert Support & Investment

The selected startups will receive support from Outlier Ventures and Futureverse's team of experts and mentors, covering various aspects such as product roadmap, community building, entity structuring, and strategic partnerships. Additionally, they will receive investment and support from Born Ready.

We look forward to following their development journeys.

Overview

Sylo is your key to connection. Now assets and data work together no matter where you are in the metaverse.

Built on The Root Network, Sylo is an infrastructure layer for data, powering interoperability for assets and users throughout the open metaverse.

Sylo’s infrastructure drives interoperability of data profiles, networks, things and events. Delivered by the Seeker Network, a layer 2 where the Sylo protocols run and are powered by the $SYLO token.

Data about you

Your Profile

The decentralized Seeker Network and Sylo Graph protocol will work alongside the FuturePass digital identity to help users store and share information about themselves that can be made available to applications and experiences.

Data about your network

Your Social Graph

Building on the social profile the decentralized social graph will help users to build connections across the metaverse and take them with them wherever they go.

Data about your things

The Asset Register

The Asset Register provides the data about the things you own and how they relate to each other. This data will be decentralized on the Seeker Network.

Data about your events

Notifications and Messaging

Sylo enables developers to send events and messages to wherever users are allowing portability of information across the open metaverse.

Verified data

Oracles

Sylo will launch a novel Oracle system designed specifically for metaverse and gaming, allowing developers to verify off-chain data and events like user rankings, achievements and in-game rewards increasing performance and scalability.

Learn more about Sylo and the Seeker Network here.

We are thrilled to share that Moai Finance has launched on The Root Network. Moai Finance is set to enrich The Root Network with an array of DeFi functionalities, including earnings, swaps, launchpad services, lending, and more. They are committed to contributing to and strengthening the diverse ecosystem that Futureverse and The Root Network has fostered.

Introducing Moai Finance

Moai Finance, a multi-chain DEX and DEX aggregator, is primarily focused on the XRP ecosystem. With the aim is to address the issue of liquidity fragmentation, a challenge arising from the limited sharing of $XRP between XRPL and various side chains. As a comprehensive DeFi solution, Moai Finance offers integrated liquidity provision and an array of financial services, including earning, swapping, lending, and staking.

Moai Finance in the The Root Network and Futureverse Ecosystems

As a versatile DeFi protocol, Moai Finance brings a suite of features to the The Root Network ecosystem:

• Moai Swap: An AMM-based DEX for asset swap.
• Moai Pool: Engage in liquidity provision to earn LP Fees, $ROOT incentives, and $MOAI rewards.

and more to come such as:

• Moai Link: Our multi-chain bridge seamlessly connects Futureverse to other chains in the Moai Finance network, enabling a diverse asset support.
• Easter Mode: This feature powers the cross-chain DEX aggregator, supporting various chains and assets, and enhancing the trading experience.
• Moai Lending: A platform for depositing or borrowing a variety of assets.
• Launchpad: A fair, auction-based platform supporting the token launch of new projects joining the network.

Fostering Community Growth

Moai Finance believe in putting the ecosystem and community first. To demonstrate their commitment, they will be allocating 10% of our total protocol revenue to The Vortex in the form of $MOAI, directly benefiting and enriching the The Root Network ecosystem.

Upcoming Milestones

Moai Finance has an exciting roadmap ahead, with several key developments scheduled:

• Q4 2023: Launch of DEX, the initiation of FutureScore Quest: The Trade, and Campaign 1: Voyage to the Future.
• Q1 2024: Launch of Moai Lending, expanding our DeFi offerings.
• Q2 2024: The rollout of Moai Link and the eagerly anticipated Easter Mode, further enhancing our cross-chain capabilities.

Links

Visit website here

Visit X here

The wait is over! Dexter, a DEX built on The Root Network, is now live in beta.

Dexter will seamlessly integrate with a diverse array of products for an adaptable, user-centric experience.

Swap any token on The Root Network, or provide liquidity to pools and earn fees on swaps.

Tokens available on Dexter:

• ROOT
• XRP
• ASTO
• SYLO

Dexter utilizes The Root Networks any-token gas with the feeProxy pallet as well as the decentralized exchange protocol encapsulated in the dex pallet.

Check it out here.

Crucible Technologies announced today it’s working with Futureverse to integrate the Emergence SDK, a toolset for game developers, with The Root Network.

This collaboration empowers developers to create interoperable experiences within Futureverse’s open metaverse ecosystem. Additionally, Born Ready Ventures, founded by Futureverse’s co-founders, will spearhead Crucible’s upcoming funding round.

Crucible’s Emergence SDK enhances interoperability for avatars, wallets, and inventory across the metaverse. Launched last month for Unity developers, Emergence is now available on The Root Network, enriching the FuturePass wallet and identity experience.

‍

Aaron McDonald, co-founder of Futureverse, stated, “The open metaverse is here. Game engines are more accessible than ever, and AI will only amplify and accelerate their development. Our partnership with Crucible will empower a new generation of developers to create memorable experiences, and to unlock new utility for all FuturePass holders.”

Ryan Gill, founder and CEO of Crucible, remarked, “The appetite for more open systems and game worlds is growing, so we built Emergence believing that we’d see the right combination of economics, communities, and experiences lead to new momentum in the open metaverse. Futureverse is another clear leader in making this happen with the same mindset. We’re proud to be creating a long-term strategic technical and commercial relationship with Futureverse. Our partnership is focused on providing great experiences for both game developers and players so that we can all build and own this together.”

This partnership highlights an ongoing commitment to advancing the open metaverse and providing innovative tools for developers.

Learn more here.

Overview

The Root Network is a proof-of-stake blockchain. Help secure The Root Network by staking ROOT and receiving rewards for participating. Anyone can use ROOT tokens to get involved.

For early participants, The Root Network has allocated 10% of the total ROOT supply for the first 260 weeks as an additional Bootstrap Reward.

Gas and network fees are collected during the reward cycle and transferred into The Vortex. In each reward cycle, participants are rewarded with newly minted Vortex tokens based on their stake and participation in the network.

How to participate

Stake

‍Stake ROOT without nominating. The low-risk way of participating.

Nominate

‍Stake ROOT & nominate validators of your choice to secure the network. You share the risks and rewards with validators.

Learn more about the Staking Protocol here.

Choosing which validators to nominate

If you choose to Nominate validators to stake with, consider the following factors to maximize your rewards:

• A higher uptime means the validator is more reliable by keeping their node consistently running.
• Commission rates vary which impacts your rewards.
• Ensure the validator is not oversubscribed. Oversubscribed validators may result in reduced or missed rewards for you.

Prerequisites

You require a minimum of 25 ROOT tokens in your FuturePass to participate in staking or nominating. Follow the steps in the How to buy ROOT guide to get started.

Stake your ROOT

1. Go to the staking site: staking.therootnetwork.com.
2. Click Start Staking.
3. Sign in to your FuturePass. Your available ROOT balance is on the staking dashboard in the top right corner.
4. Click Stake ROOT.
5. Enter the amount you want to stake.
6. If nominating, select one or more validators. Or select ‘Skip nomination’ to only stake.
7. Confirm your choices and sign the transaction.

Your ROOT is now staked.

View your staking dashboard

To view your staking activities, visit staking.therootnetwork.com and launch the app.

This dashboard shows you how much ROOT you staked, and which, if any validators you have nominated. This is also where you can change nominated validators and view and redeem your Vortex token staking rewards.

Learn more about staking on The Root Network.

For questions and support please contact: support@therootnetwork.com.

Outlier Ventures and Futureverse are proud to announce the Futureverse Base Camp accelerator.

The Futureverse Base Camp accelerator program is a collaborative effort between Futureverse and Outlier Ventures, with funding provided by Born Ready, a $50 million venture fund announced last week by the cofounders of Futureverse.

The accelerator will supercharge the best teams using The Root Network with 12 weeks of bespoke support in marketing, fundraising, legal, token design, and more, plus $100K in investment.

What do startups get out of the Futureverse Base Camp program?

• Mentoring
• Knowledge Building
• Execution
• Demo Day & Fundraising Support
• Direct support from Futureverse & The Root Network

Learn more about the program here:

Applications are now open through to December. More info.

‍

Overview

Futureverse Co-Founders, Shara Senderoff and Aaron McDonald, announce today the launch of Born Ready, a new $50 million venture fund and studio. The fund's primary focus is to accelerate the development and adoption of emerging technology ventures that hold strategic collaboration potential with Futureverse or The Root Network.

"We're incredibly excited to officially announce our Born Ready venture fund, as we seek out visionary developers and forward-thinking leaders building the future of the internet," said Shara Senderoff and Aaron McDonald, co-founders of Born Ready.

Born Ready has already made investments in a variety of companies, including former head of Adidas' Yeezy Innovation Lab's high-tech sneaker startup, FCTRY Lab, Power'd Digital, Polemos, Walker Labs and more.

Experienced and respected multi-hyphen venture capitalist-operator-entrepreneurs Senderoff and McDonald co-founded Futureverse together, along with Daniel Gillespie and Marco Brondani who also join Born Ready as partners. Futureverse is a leading AI and metaverse technology and content company that recently announced a $54 million Series A funding round led by 10T Holdings, including contribution from Ripple Labs. By rolling up 11 metaverse infrastructure and content companies into one collaborative ecosystem, Futureverse delivers the essential components for constructing any metaverse application, while maintaining one of the world's largest digital collectible communities.

In the last year, Futureverse has formed global strategic partnerships with renowned organizations and innovators including Wimbledon, FIFA, Authentic Brands Group (ABG), Mastercard, Death Row Records, Wētā Workshop, Snoop Dogg, Timbaland, Keanu Reeves and Alexandra Grant. Futureverse recently announced a strategic partnership with blue-chip NFT collection Cool Cats, integrating the iconic Cool Cats brand with Futureverse's cutting-edge technology while Senderoff and McDonald became members of the Cool Cats' Board of Directors.

Senderoff and McDonald have been investing in the web3 and blockchain space for over six years. Shara previously co-founded Raised in Space, a blockchain focused investment fund, in partnership with music-mogul Scooter Braun and blockchain leader Ripple. Through Raised In Space, Shara led investments in over 20 early-stage blockchain startups including a seed investment in Altered State Machine, a decentralized AI protocol that was an integral component of the Futureverse roll-up.

Known for her visionary strategy and foresight both technically and creatively, Shara has commanded attention and praise across the entertainment industry throughout her career in film & TV, digital media and technology. She has been named one of Forbes' "30 under 30," Rolling Stone's "Future 25," Fast Company's "100 Most Creative People in Business," and a member of Billboard's "40 Under 40" and esteemed "Women In Music." Shara sits on the board of the leading data activation, curation and identity platform, Audigent.

Meanwhile, Aaron was the Co-Founder and Managing Director of NetX Fund, which invested in over 60 portfolio companies with a thesis that the next generation of successful companies will be built on fundamentally different technology. Aaron was also a cofounder, board member, and director of Centrality, one of NZ's fastest growing technology companies that recently folded into Futureverse. Prior to Centrality, his career includes 20 years in technology as an engineer, product developer, and business leader with portfolios worth over $1b. Aaron was named Ernst & Young EY Technology Entrepreneur of the Year and is an active board member of Power Finance and Med Recruit.

We are incredibly excited to share that Futureverse have closed their $54M Series A round led by 10T Holdings, with participation from Ripple, to scale their AI and metaverse technologies.

Futureverse was founded to empower developers and users to create and engage with interoperable content and applications previously unavailable within the metaverse. The company's technology platform includes a robust suite of proprietary AI content generation tools designed to enhance the music, objects, characters and animations that make up the metaverse. By rolling up 11 metaverse infrastructure and content companies into one collaborative ecosystem, Futureverse delivers the essential components for constructing any metaverse application, while forming one of the world's largest metaverse communities powered by digital collectibles. Futureverse has also become a leader in an entirely new frontier of AI gaming. In the past year, Futureverse has launched AI-powered consumer game "AI League" in cooperation with FIFA on iOS and Android and has partnered with ABG, IP Rights holders of the Muhammad Ali Enterprises, to release the first AI-powered boxing game, "Muhammad Ali - The Next Legends."

Futureverse will use the proceeds from the funding round to continue developing the company's comprehensive technology, including its Futureverse Platform featuring "Powered By Futureverse" tools and products and The Root Network, a blockchain and suite of protocols with ready-made runtimes for building next-generation metaverse apps, games and experiences. Futureverse's previously announced partnership with Ripple has The Root Network integrated with XRPL and supports the use of XRP as a GAS token as well as the XLS-20 NFT standard.

Metaverse pioneer Aaron McDonald, tech and entertainment investor/operator Shara Senderoff and seasoned technology and information security expert Marco Brondani co-founded Futureverse along with business operator Dan Gillespie.

"The metaverse has the potential to transform the way humans engage and collaborate with one another and improve our experiences across a number of different spheres, including gaming, payments, asset management, and more. In order to reach this potential, the metaverse requires open, scalable, and interoperable infrastructure," said Aaron McDonald and Shara Senderoff, Co-Founders of Futureverse.

They continue, "Futureverse combines next-level technological infrastructure and AI-driven content to create the open metaverse we all envision. With the help of our tremendous partners 10T and Ripple, we are excited to take the metaverse from an abstract idea to a tangible, accessible, and interactive destination."

Futureverse's Series A funding round continues the company's recent momentum. In April, the company announced a strategic partnership with blue-chip NFT collection Cool Cats, integrating Cool Cats' iconic brand with Futureverse's cutting-edge technology and bringing Cool Cats NFT holders into the Futureverse ecosystem.

In the last year, Futureverse has formed global strategic partnerships with renowned organizations including FIFA, Authentic Brands Group (ABG), Mastercard, Wimbledon, Death Row Records, Wētā Workshop, Snoop Dogg, Timbaland, Keanu Reeves and Alexandra Grant.

"Futureverse has developed an immersive and vertically-integrated metaverse platform that acts as an AI technology provider, metaverse infrastructure builder, layer 1 architect, creative studio, and digital community all-in-one," said Dan Tapiero, Chief Executive Officer and Chief Investment Officer of 10T. "We look forward to supporting Aaron and his experienced team as they continue to achieve significant real-world commercial traction and scale Futureverse's capabilities and offerings."

"We are excited to continue to support the Futureverse vision and celebrate the Root Network's integration with the XRP Ledger. While we're at the earliest stages of what a project like this — and really the larger concept of the metaverse — can achieve, we at Ripple are thrilled to contribute to the foundational infrastructure layer and provide real utility to the end users of the open metaverse," said Monica Long, President of Ripple.

Overview

The team at Futureverse believe humans should be at the center of the internet. That begins now with… FuturePass, your passport through the open metaverse.

You do not have control over your digital identity on the internet. Hopefully, this isn’t a surprise. Futureverse are going to change that. FuturePass makes managing your journey through the metaverse simpler and safer than ever before.

Your Open Metaverse Passport

FuturePass is your portal in and out of apps, experiences and worlds throughout the open metaverse. It helps you to protect your identity and data.

In addition to protecting yourself, FuturePass stores your Stuff (digital assets, tokens, memberships, etc.), manages permissions, helps you build status and more.

Today, early access to FuturePass launches for Fluf World asset holders.

Learn more about FuturePass here.

Overview

Futureverse announced today a merger rolling up eight metaverse companies into one collaborative ecosystem with the united goal of improving the Web3 and "Open Metaverse" experience. Futureverse is the culmination of five years of strategy, research and development to create the foundation for an open and scalable metaverse infrastructure with world-class content and a highly engaged community. Futureverse is now a company of over 300 full-time people and is co-founded by Aaron McDonald, Shara Senderoff, Marco Brondani and Daniel Gillespie.

For the metaverse to become a reality, infrastructure is critical. The Futureverse infrastructure consists of four core tools (identity, artificial intelligence, communications and payments) all vertically integrated via The Root Network: a decentralized blockchain network optimized for user experience. A rich layer of user-owned content designed with storytelling at its heart brings it all to life. The Futureverse roll-up combines all of these core elements needed to create the "Open Metaverse'' under one roof, to improve user experience and accelerate adoption.
‍

The Futureverse roll-up includes the following companies:

Altered State Machine‍

Leading AI protocol for AI powered metaverse and game characters and content.

Non-Fungible Labs‍

Creative and engineering studio, designer of ecosystem avatars and world environments (including FLUF World) as well as "DOT", Dynamic Object Transformer, 3D programmatic avatar and asset creation software.

Sylo‍

Developer of the Sylo protocol, decentralized communications for the metaverse powered by The Seekers gamified node infrastructure.

Centrapay‍

Digital asset payments SDK, enabling Web3 payments in popular global payments networks.

Centrapass

Developer of the decentralized digital identity protocol/SDK and decentralized asset custody protocol.

Immersve‍

A multi-chain payment protocol and web3 / metaverse Mastercard® product that bridges web3 and metaverse infrastructure with the Mastercard® network.

Shadows Interactive‍

An LA based Animation Studio and creator of the Party Bear collection.

Altered Phoenix‍

A gaming studio with experience developing gaming titles covering a range of genres and platforms.
‍

In addition to the technology infrastructure, this merger positions Futureverse and their digital asset IP as a leading ecosystem for total NFTs, NFT transactions, unique holders, and NFTs per holder.

Futureverse Co-Founder Aaron McDonald, "For the past five years we've been developing the tools and infrastructure to co-create the future with our communities. We're enabling companies and creators to deliver the open metaverse experience that they want for their audience. We don't see the metaverse as one super app controlled by a single company. Futureverse is your seamless portal in and out of all apps in the metaverse; with you comes your passport, friends, communications, finances and content."

"A lot of companies are telling you that they're building the future. We are not," says Futureverse Co-Founder Shara Senderoff. "We believe that the future is a collective vision. The future is the only truly decentralized idea. Futureverse proposes a more virtuous model for the internet both in values and technology, designed to shape what's to come and who controls it, together."

In addition to the development of new content to showcase the technology, Futureverse has already amassed an expansive cultural footprint both within the Web3 space and beyond, through strategic partnerships and a variety of projects with the following talent and companies: FIFA, Authentic Brands Group, Muhammad Ali Enterprises, Snoop Dogg, Timbaland, Keanu Reeves and Alexandra Grant, with more to be announced soon.

The Technology

The core elements of the Futureverse include a new blockchain network - The Root Network, an identity protocol, artificial intelligence platform, a communication protocol, payments rails and character creator technology. With user safety and user experience at its heart, Futureverse aims to lead the world in onboarding the next generation of open metaverse and web3 users, all collectively building and creating the future together. Over this infrastructure, a rich content layer creates powerful community network effects.