w@y_p01nt

w@y_p01nt (waypoint) is an interoperability framework for the metaverse.

It enables 3d metaverse creators to build, mint, and sell interoperable metaverse worlds, all accessible from the browser.

The application is entirely serverless, and runs on a single-page react app in the browser, hosted on IPFS.

High level features:

• Build an interactive 3d virtual world, all from the browser.
  • Drag and drop files to build a 3d metaverse. Current files supported are
    • images of .jpg and .png
    • movies of type .mp4
    • 3d models of type .glb
  • Videos have spatial audio
• Upload an entire virtual world to IPFS. This world is blockchain agnostic and can become part of any NFT.
• Load the virtual world from IPFS
• Mint a virtual world as an erc721 compatible NFT to Polygon, or any EVM compatible blockchain.
• Load the virtual world NFT in any marketplace as an interactive application which is loaded from IPFS
• If you are the owner of a world, you can edit it and update the world via a smart contract operation.
• If you are an owner of a world create an on-chain portal between virtual worlds. Travel through the portal to go to the target world.

Description:

Our first approach to achieving this goal is to build a tooling stack for users to easily architect and deploy their own spaces which are entirely interoperable and decentralized. These are not just buzzwords - this is accomplished by having the entire data structure of items to be rendered stored between the blockchain and IPFS. We use the blockchain to store metaverse metadata, such as tokens indexing individual worldboxes. There are no private servers anywhere in the content delivery loop. We could also conceivably host the entire front-end with deterministic rendering logic on IPFS. Each token itself has its own unique metadata structure: it could hold other token objects: ie. your virtual chair is a token in your virtual penthouse. Using this open data structure, every render scene is a waterfall of dependencies which create a functionally deterministic render for each user looking at a token.

We have implemented a special data structure for portals which provide horizontal links between spaces, allowing you to actually walk between these spaces. Metaverse interoperability comes from using a tokenID as the universal scene pointer, from which all linked files and dependencies can be deterministically rendered by any browser. This is what we have built.

We have also implemented a special data structure for portals which provide horizontal links between spaces. Portals point to other tokenIDs, and when walked through reroute the browser to render the scene at the tokenID specified within the portal. This can conceivably become a standard for spacial traversal across different contract types: all you need is an endpoint for another space on chain.

The really important part here is that we have not build a platform. All of the logic for the construction of these spaces exists between the blockchain and IPFS - so when you are walking between spaces, you are truly walking the roads of a decentralized metaverse.

You can use our front end to mint your own spaces from scratch, adding your own data, storing it all onto IPFS, and then minting the scene as a token. Once that is accomplished, you can add portals as a special blockchain metadata field to your token which point to other tokens. This renders the portal in your world, which is fully functional and when used transports the user to the specified scene token.

For more details on how it works, refer to the github readme here: https://github.com/landaxr/waypoint#how-it-works

We use web3.storage to store erc721 token metadata, scene graphs, the scene files, assets, and the serverless application

When building a scene, and a user drags and drops files into the scene, all those files are stored as local File variables. When uploading the scene to ipfs, the scene graph and all of those files uploaded together using the web3storage sdk; This way they are all packaged together into the same folder on ipfs.

The scene can then be loaded from IPFS directly, without it needing to be tied to a specific token. This would allow these scenes to be blockchain agnostic.

To enable these worlds to be tokenized, we have smart contracts that enable these ipfs folders to be owned by a token. we used scaffold-eth as a contract + subgraph building and deployment codebase, along with using its debug front end for testing. We deployed to Polygon as the complexities of spacial relationships stored onchain will quickly get too expensive for mainnet use.

We utilize the graph to index chain state updates and pass them to the front end for rendering. When an action happens onchain (ie. the creation of a portal) that information is indexed by the graph and delivered to the user in live time - updating the scene as they are inside of it, complete with the functionality of the object - in the case of portals, this is the ability to enter into another world.

IPFS does a huge amount of the heavy lifting, and allows us not to rely on any private server infrastructure. This entire interoperable metaverse stack simply uses the Blockchain <-> IPFS <-> Browser. Because of this architecture, it is essentially infinitely scaleable from the outset. There is never a central point of failure for an entire metaverse ecology with w@y_p01nt - and users can specify exactly how performant they want their space uptime to be simply by engaging with IPFS hosted services - or hosting it themselves.

The blockchain acts as the metadata store for metaverse spaces. This allows an arbitrary amount of complexity and interoperability native to the network of resultant spaces. We chose to build out portal functionality, as it highlights the connections possible between spaces, which is especially interesting when it is considered that there are no private servers running anywhere in this stack: you are enacting a spacial traversal between two Blockchain+IPFS hosted metaverse spaces.