FABSTIR (PLATFORM)

THE DAO OF DAOS

Yellowpaper (draft 1m) By Jules Lai (aka Julian Bushell) jlai*at*fabstir.com

October 2021

1. Abstract

Fabstir aims to create a paradigm shift for the development of decentralized applications to create a world of secure and safe smart contracts. To create a burgeoning community of specialist solidity developers and a platform for rapid development of DAOs by business domain experts, opening the ecosystem for a much wider range of dapps, while guaranteeing the safety of users through secured and audited smart contracts and DAO templates.

1.1 Secure Development

This paper explains a new way to renumerate expert smart contract developers to incentivise the writing of secure code, and to create an environment for auditors to help enhance further the security of blockchain development.

1.2 Domain expert creators

Also described is a new way for business domain experts to use these “audited” smart contracts to quickly build DAOs for testing or production without the need to write code, that allows instead concentration on the business logic and the visual flow of tokens and NFTs.

1.3 Smart Contract Marketplace

To facilitate this is a new platform that sits atop the blockchain that hosts a marketplace for secure, audited smart contracts. This creates a two-sided marketplace of auditors and smart contract developers, and produces contracts to be used in Fabstir’s visual programming interface to build DAOs.

Smart Contract Marketplace

2. Problem Statement

2.1 Hacks

It is a wonderful thing that people are sharing code through open source. Projects can get off the ground much quicker and then be improved/tailored to launch new projects. For Defi this brings in vast money into the decentralized ecosystem from those attracted to the promise of yields from the large number of DeXs available. But with that comes bad actors who can exploit the lack of effort in understanding this shared code, combined with the lack of programming experience and hurry to rush new products to market, often without an audit. This has been shown to lead to gaping flaws in security of the smart contracts causing losses in the millions due to hacks of allegedly “secure systems”. Decentralised applications and exchanges are largely unregulated, so if cryptocurrency is stolen by hackers, then usually there is nothing investors can do and funds are lost. This damages confidence in the entire decentralized ecosystem, and raises concerns from lawmakers and regulators around the world about the safety of this industry as a whole.

2.2 Unsecure Code

Another cause of the problem is that developing in Solidity is difficult and warrants expert technical skills. The immutable nature of blockchains means that smart contracts must work perfectly the first time. This is in stark contrast to the traditional world of development where iterative failures create stronger code. It necessitates a specialized skill set that most developers don’t have. The EVM (Ethereum Virtual Machine) that executes the contracts has a tiny amount of throughput compared to modern computers, and the cost of gas that a contract can use can be costly, hence computation and storage have to be minimized. The familiar Javascript language to onboard developers into this world of blockchain development, doesn’t prepare at all for the rigorous nature of formal testing and verification required to write secure code, and so this is often overlooked. But the cost of this mistake can be extreme if it leads to users losing funds. Secure code comes from an entirely different mindset. Qualities includes a deep understanding of programming and tools plus the foresight to examine the many permutations that could lead to an exploit. A paranoid mind is required. It is a challenge for even the most experienced developers to be aware of possible exploits.

2.3 Fewer Apps beyond DeFi and NFTs

Indirectly, this leads to another problem; the scope of projects that are developed. The difficult development environment can discourage developers from writing decentralised applications that explore difficult problems such as identity, ownership property, governance and fund public goods. Time spent on these can be seen as ‘not worth it’ given that code base may not be available to fork and the route to renumeration is not obvious given the difficulty. Now that there are layer 2 and side-chain solutions to the problem of Ethereum’s high gas costs and low transaction speeds, the opportunities to develop the new breed of decentralised apps is there and systems to produce secure smart contract code and easier rapid development are badly needed.

3. Some Fabstir Features

3.1 Secure Audited Smart Contracts

The ability to only use secure audited contracts written by specialists when building a dapp. Thus, making it more secure from the start.

3.2 Marketplace for Auditors

An auction site where developers can easily submit their verified smart contracts to be audited, to where auditors get notified and can bid for the audit job. These smart contracts can then be sold for use in dapps and DAOs on the Fabstir’s smart contract marketplace. Application developers and business domain experts are then able to purchase these contracts for use in the visual programming tool, knowing that they have been audited. Solidity developers are then renumerated for delivering said secure smart contracts. Thus this will also help the decentralised eco system by producing dapps with less security flaws and possible exploits.

3.3 Marketplace for Developers

An eco system where solidity developers are suitably rewarded for producing secure smart contracts that are sold on Fabstir’s smart contract marketplace.

Smart Contract Sale

Over time, the best developers will build up a reputation with higher average ratings for the contracts they code. Potential clients will be able to read user feedback, drop the smart contracts into the visual programming tool to try out, before buying.

3.4 Visual Programming

Business domain experts that know what is required for their business can simply plug and play with these secure audited smart contracts and produce working DAOs in minutes. No solidity coding required. This is a game changer that can bring a whole new set of users to produce a whole new wave of dapps.

3.5 Next Generation NFTs

With the implementation of EIP-3601 NFT and FT with Royalty Distribution System, Fabstir is perfectly placed to move beyond property NFTs into a whole new world of use cases. With property NFTs that have become huge recently, Fabstir offers ways to monetarise through fractionalisation of said NFTs. Plus out of the box time-locked contracts, allowing for lending out NFTs for specific periods. Beyond property NFTs, Fabstir supports NFTs as services. Whether that be for subscription services or for renumeration of services, all this is available as with all smart contracts on the platform by simply dragging and dropping using the visual programming tool. The Fabstir architecture naturally lends itself to de-fi. It would be straight forward to integrate derivatives for NFTs into Fabstir’s platform, as smart contracts can be parents nodes to existing NFT contracts. For example, derivatives for NFT collections.

3.6 Incremental Upgrades

Smart contracts are built utilising EIP-2535 Diamond Standard. Meaning that any contract can be upgraded down to the individual function and state level. Plus the standard allows for no limits in contract sizes and hence the amount of functionality that can be added. This allows any contract on the platform to be updated in the future to account for new functionality or to address security issues unknown at the time of first release. Incremental upgrades creates a marketplace of living and evolving code that is continuously improved.

3.7 DAO of DAOs

Every dapp built on Fabstir’s platform can have their own governance token by default. The governance allows for voted in verified functionality upgrades, to be automatically executed after a time-locked challenge period. This process can be automated with little to no human intervention. The ability to create DAOs from the smart contracts on the platform allows for complete decentralisation that is resistant to governments, regulatory bodies, and censorship from centralisation. From Fabstir’s secure smart contract marketplace and ease of use to create DAOs with its visual programming tool, is an opportunity for a large number and variety of DAOs on the platform. As more DAOs are built on the platform, they bring in their own users who join the Fabstir ecosystem. These users will include crypto enthusiasts who may be auditors, developers, and entrepreneurs who also want to make their own DAO. Thus in turn, generating a positive feed back loop.

4. Fabstir Platform

Fabstir Platform

4.1 Governance

Users that create decentralised apps on Fabstir’s platform automatically gain a token that can be used for governance. Voting power is quadratic and can be delegated. New proposals will be able to be added directly on the platform or through a third party’s dashboard that supports Compound’s governance interface. Fabstir itself, is to have a DAO that is the platform with its own governance token, Stircoin.

4.2 Smart Contracts

Fabstir comes with a range of free smart contracts to use right away, with the visual programming interface, to rapidly develop dapps; ranging from time-locked contracts, to investment pools, to NFTs to secondary market contracts and so on.

4.3 Tokens

Fabstir supports ERC20/777 fungible tokens. The Fabstir platform has its own governance token, Stircoin. Every decentralised app created on the platform has its own fractional token that can be used for governance or for distributing funds to holders via ERC20/777 tokens. The fractional tokens themselves can be used for payments, sold on the secondary markets or used for other purposes. For example; projects that require funding at different stages in their lifecycle can have a token for each stage. Both Stircoin and fractional tokens are ERC777.

4.4 NFTs

NFTs are the heart of everything Fabstir. Architecturally designed to make the best use of NFTs as property, legal contracts or more. This opens up a whole breed of dapps that go beyond current property NFTs. Fractional tokens also allow investors to stake into an NFT pool and receive rewards via fungible tokens. These pools can be combined to create chains of flows of tokens for investment into multi-stage projects. Pools can be parents of other pools for projects that are produced by a collection of other pools. Fabstir enables very fine control over the flow of tokens and governance between owners, pools, and investors.

4.5 Markets

There are a number of markets built into Fabstir’s platform. A market for fractional tokens, so if an investor no longer wishes to participate in a DAO to invest, receive rewards or to participate in governance, they are able to resell their tokens on a secondary market auction. There is also a market for smart contract audits where users can submit verified contracts to be audited, and auditors are able to bid for the job to audit the contracts. The flexibility of Fabstir’s DAO and dapp builder allows users to create more markets for the platform for different use cases and markets.

5. Development

5.1 React

Fabstir’s visual programming tool was built using React and react-flow, communicating with the blockchain using ethers.js

5.2 Visual Programming

On Fabstir, users can rapidly create decentralised applications using a visual programming interface that guides the user to plug and play with secure smart contracts whilst instantly seeing the results. With built-in governance facilities these applications can be DAOs from the start. For more detail on the visual programming interface, please see section 7.

5.3 Auditing

Fabstir aims to build a thriving market where skilled developers are rewarded for writing secure contracts by selling them on Fabstir’s marketplace to DAO and dapp builders. They can then plug them together to produce customised dapps specific to their needs. These dapps on Fabstir, can then be submitted to an automated auditing auction system of auditors to further ‘polish’ these contracts with more security. This facility will be open for the domain experts to submit their entire decentralised apps to said auditors with the hope that most security flaws would have been ironed out by this stage, and auditors’ insightful experience would now be of most benefit. Source code is submitted as an NFT and verified on Etherscan.

5.4 Solidity

Fabstir platform is written in the latest version of Solidity using OpenZeppelin contracts where possible.

6. DApps

6.1 Finance

Fabstir has a complete network of flows possible for ERC20, ERC777, ERC721 and ERC1155 tokens with time-lock facilities built into its platform. Users can build by using the visual programming interface (see section 7) to plug smart contracts together. Naturally lends itself to be building blocks for financial products such as derivatives.

6.2 Royalties

Fabstir’s support of EIP-3601 allows for projects where investors can receive a return on their investments. The amount received would be in proportion to how many tokens an investor holds compared to the token’s total supply. The contractual agreement would be the NFT. This opens up the landscape of dapps to many types of business.

6.3 Reputation

Fabstir’s rapid, secure development environment would be ideal for various projects startups that would explore identity and reputation to support for example EIP 3722 for decentralised social media. These are some of the hard problems that Fabstir’s development environment can help solve.

6.4 Social

With layer 2 solutions and the upcoming sharding of Ethereum, it’s possible to have micro-payment rewards of user content from other users that would cost trivial gas fees. The hope is that to be a main driver for decentralised networks that are not subject to centralised censorship and for fairer fee payment to content creators.

6.5 AI

Fabstir would like to explore and support projects that use AI to benefit a decentralised society. From better filtering of factual information to autonomous tasks that help save time and many more use cases.

6.6 Public Goods

Fabstir will reward projects on its platform, that provide public ‘good’ to the blockchain community. See later for details.

7. Visual Programming

7.1 Why visual programming?

Business domain experts have deep knowledge in their field of expertise. This could be in data science, financial markets, retail etc. To write secure solidity code also takes expertise and experience. Finding people with domain expertise in both business and solidity coding, is rare. With layer 2 solutions comes much lower fees and faster transaction speeds that will usher in the next wave of next generation software that will be rapidly developed to market. To help ensure that this landscape is not littered with unsecure code and headline breaking hacks, leading to people losing their funds, Fabstir gives tools for business domain experts to thrive in rapidly building secure dapps and for specialist solidity developers to thrive, in being able to sell secure smart contracts to the business domain experts. So, dapp builders have an alternative to forking exiting code, or writing unsecure solidity code due to lack of experience. Instead, they can use Fabstir’s visual programming interface to plug together audited, secure, smart contracts and utilise their area of business domain expertise to build secure, decentralised app for their needs. This gets deployed to a testnet where they can submit to Fabstir’s audit marketplace, and have a professional auditor review the generated solidity code. What follows are cropped screenshots from Fabstir’s working system called Visual DAO Builder....

7.2 An example of prototyping: Transfer from One Account To Another

Transfer from One Account To Another - part I

In the visual programming editor, to start, drag smart contracts from a side panel (out of shot and not shown here).

Transfer from One Account To Another - part II

Connect up the nodes. Input handles are on the left, output handles on the right of the node. Red handles relate to tokens, green handles are for fractional tokens. So for this example, the output of the USDC faucet is connected to the input of Investor1’s account. Once the user types in 50000 and hits enter, that amount is minted and added to the account balance.

Transfer from One Account To Another - part III

Notice how the user is guided, as connection handles are only made available as progress is made.

Lastly, the output handle of Investor1 account is connected to the input handle of Investor2 account to transfer $10000 USDC to Investor2.

7.3 Fractional NFTs

Next is a cropped screenshot of the visual programming tool that shows the dapp that was created in a few minutes that allows for fractionalisation of NFTs with a Dutch auction secondary marketplace. Particular points of interest are circled and numbered, with comments below the screenshot… For a production system, a frontend coder will be able to connect to the solidity smart contracts generated and deployed from the visual program tool, using web3 or ethers.js as normal.

Retroactive Public Goods

  1. Fabstir’s platform is a DAO of DAOs. To start a DAO on the platform, by default, the first node is already created and in the editor pane. That node is the factory node and is the root node that instantiates smart contracts.
  2. When a creator account is connected to the NFT pool then the user can upload a file, name it, set a price and it is minted and stored on IPFS. A link to it is hashed and stored as an ERC721 NFT burned on the blockchain.
  3. This NFT can be fractionalised via the MT1 tokens, and the creator can decide how many of these tokens they wish to keep for themselves at the time of creation; 1000 in the example.
  4. The remaining fractional tokens can be offered for sale. Here Investor 1 purchased with $20,000 USDC.
  5. Leaving them with almost 308 fractional tokens of the NFT in their account.
  6. Here a secondary market smart contract was connected to the NFT pool for fractional token sales. A Dutch auction is a type of auction where the price goes down to a minimum reserve price over a specified time.
  7. Investor 1 connects the green output handle from its fractional tokens to the secondary market, and is then able to deposit 200 fractional tokens for auction sale.
  8. After filling in the start price, reserve price and duration of the sale, a market item is created with an input handle to connect to.
  9. Any account can now connect to this market item and purchase. In this case, Investor 2 spent $5000 USDC…
  10. Investor2 buys almost 110 fractional tokens. Investor1 account reduces to around 195. Fees already taken out.

7.4 Retroactive Public Goods

Retroactive Public Goods

Fabstir has its own solution to retroactive public funding; for financially rewarding projects that may not have an obvious business model, so not necessarily profit driven quantified, but still produces benefits that many in the eco system can derive from. Vitalik Buterin himself, mentioned the need for solutions to this problem. This screenshot shows a quick working example built using Fabstir’s visual programming tool of a retroactive public goods solution. A full blown solution would use the solidity contracts generated and an app specific frontend . Basically, the Results Fund distributes ERC20 tokens to deserving projects on Fabstir’s platform. It does so based on the proportion to which Project1 and Project2 brings value to the eco system as decided by a governance system to be worked out. Each project’s account receive fractional tokens RT1 from the Results Fund in the proportion that each brings value. Then later, the Results Oracle account transfers USDT of $100,000 to the Results Fund pool which is then split between the two projects in the proportion of RT1 tokens held . Either of the projects can then withdraw their share of the USDC rewards at their leisure, by pressing the withdraw button. In this example, Project 1 holds 40 results tokens out of 100, hence receives almost 40% of the $100,000 payment. Note, a percentage of these rewards goes to the platform as fees. Similarly, Project2 receives almost $60,000 USDC. Later more funds can be deposited, or fractional tokens distributed to change the proportions, or another results fund pool created for the next distribution round. Pools can have NFT’s as proofs to agreed governance decisions etc.

8. Upgradeable Smart Contracts

The ERC-2535 Diamond Standard: Multi-Facet Proxy (author Nick Mudge), specifies a flexible and granular way to upgrade smart contracts. On the Fabstir platform, each smart contract that needs to be upgraded is its own diamond. At its heart, each diamond is a smart contract itself and uses a lookup table of function hashed signatures with addresses to redirect delegatecall in its fallback method to the implementation of the function to execute. In fact, the implementations live in their own smart contracts and hence an upgradeable smart contract on Fabstir consists of a diamond contract and several ‘facet’ smart contracts that house the function implementations. This split into several smaller contracts overcomes the 24KB limit on contract code set by SpuriousEIP –170 and hence Fabstir smart contracts can be of any size. On Fabstir, gas cost for upgrading can be lower because when a dapp, for example, is made of multiple contracts and only one smart contract needs to be upgraded, then as long as the diamond address remains the same, individual functions can be swapped for a newer version of the function implementation per facet. Also new functions can be added, and existing functions removed. This fine granular upgradeability is a feature of the diamond standard.

Diamond Standard

It's the DAO builder visual programming tool that instantiates these diamond structures, so depending on how the user combines the nodes, determines the diamond structures deployed. Since the diamond addresses remain the same, care only has to be taken that existing user’s contracts within their dapp doesn’t call functions that no longer exist or functions whose signature has changed. For these cases, the dapp code for the caller smart contracts will have to be changed and upgraded also.

9. DeFi Fees Explained

Fabstir has DeFi smart contracts that consist of a contract that is an automated market maker for token pair pools, and a contract for an exchange so that a token can be swapped for another token type. The visual programming tool makes it extremely easy to drag and connect AMM (automated market maker) pools to exchanges, allowing for multiple pools to be connected. This allows for an exchange to poll each connected AMM for their quoted price in order to select the cheapest. Slippage is defined as the difference between the quoted price and actual price that the user signs for in their wallet and the maximum can be set so that the transaction reverts if this limit is exceeded. Fee structure is in two parts; % to liquidity providers and % to Fabstir platform For the sake of this yellowpaper, let’s say that they are set to 0.2% and 0.1% respectively. The fees are generated from every exchange transaction. The 0.2% fee gets added back to the AMM pool. So, if someone buys ETH with USDC then 0.3% is added to the USDC to pay, and they see that when confirming the transaction through a wallet. When someone withdraws from the AMM pool , their LP tokens are burned and in exchange two tokens are received back from the pool, with amounts to the proportion with the total amount of LP tokens held (by liquidity providers) from the pool with the addition of the fee rewards.

10. NFT Fees and Payments

Transaction fee for NFTs on Fabstir is provisionally set at 3%, and that goes to the Fabstir platform. When an NFT is minted on Fabstir, this additional fee is added to the cost. When the NFT’s fractional tokens are transferred, half of this fee is collected at the time the sale is created on an auction, and the other half collected as an additional cost to the purchaser. The fee from an NFT sale is collected from the buyer. The creator of the NFT is free to set a resale fee, that is transferred to them on the sale of their NFT, and all subsequent sales of the NFT on the secondary market.

10.1 Royalties

Part of fractional tokens appeal when used with NFTs as outlined by EIP-3601, is that royalties sent to the NFT pool, get distributed automatically to fractional token holders in the proportion of the number of tokens held. This lends itself naturally to investment of products where the investors are able to receive a return from their investment that helped to cover the cost of the product development. This type of investment does not imply ownership of property or IP, unless stated by the NFT.

10.2 Subscription payments

10.2.1 An implementation that uses NFTs

Subscription tokens

Subscription payments work by the subscription service provider creating an NFT pool on Fabstir for subscription tokens. Once the user pays the subscription, an NFT (that can contain a hash of the terms and conditions) is minted and transferred to the user’s wallet address, whilst subscription tokens are minted in the pool and affectively burned at a rate of one per fixed interval, for example once per day. In the example, four subscription tokens are left, hence four days until the subscription expires. The service provider can check this simply by requesting the total number of subscription tokens left in the pool and disabling its service if there are none left. The user can purchase more tokens to extend the subscription period. Can also sell the NFT, hence the subscription, to another user without affecting the expiry period, that carries on until it expires or the new user tops up the pool.

10.2.2 Minimising subscription gas costs

Gas efficient subscription tokens

Using ERC-1155 multi token standard instead of ERC-721, reduces the cost to set up a new subscriber. Affectively, the service provider pays for the cost of deployment of two smart contracts, removing the need for deployment for each subscriber. It is deployment on the blockchain that has the higher gas costs.

Each NFT token from ERC-1155 will have a corresponding ERC20 compatible subscription token pool for it in the Fabstir smart contract. For this example, My TV Service sets up a subscription service for their channels. This deploys two smart contracts; an ERC-1155, and a Fabstir smart contract for subscription token pools that points to the ERC-1155 contract. For new subscriber Alice, who paid with USDC for a year’s subscription, the ERC-1155 contract sets up a balance for a new NFT token id 1234 and sets this balance to 1 only and no more, thus making it non-fungible. This NFT token is then transferred to Alice’s account. Then in the same transaction, the Fabstir smart contract for subscription pools adds a corresponding new balance for fungible subscription token 1234 for amount 365. When My TV Service’s client app checks the Fabstir pool for Alice’s balance, it will see that she has a whole year left on the subscription. The next day, My TV Service’s client app sees a balance of 364 and so on; assuming the subscription tokens are burnt at one per day. Once the balance drops to zero then the client app sees that Alice’s subscription has expired and she can no longer use the tv service, until she pays to top up her balance of subscription token 1234 tokens in the pool. Or maybe after a grace period, MyTVService decide to disable/burn her NFT. Note that a subscription provider can set up an unlimited number of subscribers and can set up as many subscription services as needed. For example My TV Service can add another subscription service for their premium channels. This will again incur the gas cost once of deploying an ERC-1155 and a Fabstir smart contract for subscription pools. Another approach would be to use split id bits for the token id, as suggested by the EIP-1155 Multi Token Standard proposal. Here, the top 128 bits would be the subscription service number and the bottom 128 bits the index of the NFT to make it unique. This therefore saves the additional deployment costs for further subscription services.

10.2.3 Advantages and disadvantages of both implementations

This section outlined two methods of implementation for subscription payments, one based around ERC-721 and the other uses ERC-1155. The former has the advantage that each NFT can have completely unique metadata but each new subscriber would have a gas cost to mint each NFT. The latter implementation has a mint cost for the ERC-1155 contract but all subsequent NFT tokens it issues for subscribers does not incur this cost. Here, metadata is shared across all of the NFT tokens, but the standard does allow for wherever {id} appears in a metadata URI JSON Schema, substitution with its token id. Thus a line in the metadata JSON file “image”: "https:/s3.amazonaws.com/your-bucket/images/{id}.png", a client app should replace with for example “image”: "https:/s3.amazonaws.com/your-bucket/images/00000000000000000000000000000000000000000000000000000000000004d2.png" for token id 1234 (0x4d2 in hex). Thus each NFT can still have individual image files.

10.3 NFT Rentals

Fabstir's subscription service can be used for NFT rentals. Current rental methods require a collateral upfront to cover price of the NFT in case its lost, which can be extremely expensive for some NFTs. Using Fabstir's subscription, a ERC-721 or ERC-1155 NFT is hashed to the same hash as the original NFT, and the original NFT is held in escrow contract and cannot be used. When rent is over (subscription token drops to zero balance) then the ERC-721 or E RC-1155 NFT is automatically burned, and the original NFT can be released back to its owner. So no collateral required. Rentals on single NFTs uses the subscription methods based on ERC-721. Rentals on collection of NFTs, such as game assets, can use the subscription method that uses ERC-1155 to save on gas fees.

10.4 Micropayments for Tipping

Tipping allows a user to show appreciation for an NFT that monetary rewards the NFT’s holder. Micropayments for tipping is a use case that can only operate effectively if the gas to do so is low enough. This section outlines an implementation that provides tipping to any NFT whether it is an ERC-721 or a NFT or fungible token in an ERC-1155. Tips can be sent in batches to save on gas costs.

interface ITipToken { function setApprovalForNFT(address holder, address nft, uint256 id, bool approved) external; function isApprovalForNFT(address holder, address nft, uint256 id) external returns (bool); function tip(address nft, uint256 id, uint256 amount) external; function tipBatch(address[] memory users,address[] memory nfts,uint256[] memory ids, uint256[] memory amounts) external; function deposit(address user, uint256 amount) external payable; function withdraw(uint256 amount) external payable; function balanceOf(address user) external view returns (uint256); function balanceDepositOf(address user) external view returns (uint256); function rewardPendingOf(address holder) external view returns (uint256); }

setApprovalForNFT registers an NFT for tipping, provided that the NFT has approved the tip token contract. It checks that the holder account is the NFT holder and reverts if not. There is no limit to how many NFTs that can be registered. When a tip is sent, the deposited ERC20 that backs the tip is sent pending to the NFT holder and the tip itself is burnt. tipBatch allows a provider who wishes to save gas costs, to send batches of tips from many users for the NFTs to the NFT holders in one transaction. deposit function allows a user to buy tip tokens with ERC20 compatible tokens. The deposited ERC20 can be held in the tip token contract account or an external escrow account, to be used later for when a holder decides to withdraw. balanceDepositOf returns the deposited balance of a user. This divided by the value returned from the tip token contract balanceOf function, can be used to calculate the cost of each tip. rewardPendingOf allows the holder to find out how much money they are owed, and can choose to withdraw, for example, when there is enough accumulated that it is worth the gas costs to do so. Tip tokens can also be transferred directly to other users as they are ERC20. Each NFT that can be registered to receive tips, can be an ERC-721 or an NFT in an ERC-1155.

_ A tip token contract can implement ERC20 to allow for transfer of tips directly between users.

11. The Frontend Builder

The frontend builder takes the node graph output from the DAO builder visual programming tool, and builds a modern CSS frontend website for the deployed dapp. The website will be a React project, the number one JavaScript frontend framework, thus making it easier for builders to customise the exact look and feel to taste, themselves or find someone with the necessary React and CSS skills

The Frontend Builder

{ "id": "pairexchange_1", "type": "pairExchangeNode", address: "0xB0D4afb8879eE9F52c28595d31B441D079B2Ca07" } { "source": "pairammpool_1", "sourceHandle": "toExchange", "target": "pairexchange_50", "targetHandle": "fromPairAMMPool", } { "id": "pairammpool_1", "type": "pairAMMPoolNode", address: "0x36D02cA8a0983159322a80FFE9E24b1cafF8B570" } { "source": "pairammpool_2", "sourceHandle": "toExchange", "target": "pairexchange_50", "targetHandle": "fromPairAMMPool", } { "id": "pairammpool_2", "type": "pairAMMPoolNode", address: "0x82c01223e51Db87e16B03A24687DEF0E294da6f1" } . .

A much-simplified JSON output of a node graph from the visual programming tool. The frontend builder uses the type attribute to load the correct React component with modern CSS. The JSX includes the input dropdown selection of the tokens to swap (the token list is constructed from the AMM pools attached to it), plus input boxes for amount to swap, and input for slippage % etc. Along the top can be tabs for exchange and liquidity. Pressing the latter tab, opens up another page to select the tokens and amounts to add as liquidity to an AMM pool. Frontend builder will then work on the next node, again uses the node type to load the correct React component and CSS for it, constructing the input form and navigation tabs. This process continues until the entire dapp frontend is built.

12. Fabstir’s use of Soulbound tokens and what that means for Web3

At the heart of Fabstir’s platform are businesses that can trade with each other based on trust. Previously this had not been easily possible in Web3 as there had been no mechanism in place that made it easy to lookup a third party’s credentials without KYC or having good enough offline proof that the onchain account belonged to a reputable entity.

Now with soulbound tokens, the community itself can vouch for each other and let the most respected tokens rise to the top to let that drive trust throughout the eco system.

Fabstir fully supports an implementation of ERC-4973 account-based Tokens (ABT). Though for those not familiar with World of Warcraft where the term “souldbound” originated from, instead Fabstir uses the term “badges” for this and for ABT.

Account-based tokens can only be transferred once from the issuer to a receiver’s account address. Thus, they do not have a price, like an ERC20, but like an NFT, they are non-fungible. In Fabstir’s implementation, only the holder of the account who has access to the private key, has the option to burn these tokens. Similarly, only the issuer has the power to revoke these tokens from the receiver.

12.1 Use Case 1

The Frontend Builder

A film insurance company does a risk assessment of a movie project and issues a badge to the filmmaker that it is willing to offer an insurance policy for the movie project in the hope of future business. The filmmaker checks that the insurer is legitimate (the insurer has published its badge addresses on its website) and accepts the badge.

The Frontend Builder

An investor sees that the film project has a badge from the reputable supplier of film insurance and is now more likely to invest in the movie.

12.2 Use Case 2

A filmmaker thinks that their movie qualifies for tax incentives as it will be shooting in country X and requests a badge from an organisation who deals with certification for that country. The organisation’s certification analyst issues a badge to the filmmaker that indicates that their project does indeed qualify. Filmmaker sees the badge pending and accepts the badge. Investor interested in the projects sees the badge and realises that they can offset their tax burden by investing in the movie project.

This is just a flavour of the many new use cases that Fabstir brings via its implementation of badges (soulbound tokens).

13. How does Fabstir make money?

Fabstir collects fees from many sources of transactions on its platform. This includes deposits made to NFT pools, rewards sent back by DAO creators to itself or investors. Fees from secondary market sales of tokens, from audit fees and so on. This gets collected to a results fund and distributed back to projects on the Fabstir platform via retroactive public goods funding and to Fabstir’s platform team.

14. Conclusion

Fabstir is a platform that is a paradigm shift in the development of DAOs and decentralised applications. It gives business domain experts, via Fabstir’s next generation visual programming tool, the means to rapidly build dapps without the need to code in solidity. This allows concentration on the business logic, and rapid production of dapps that works for business. Fabstir will have a thriving marketplace for experienced solidity developers to build the secure smart contracts for the business domain experts to use in the visual programming tool. Enhanced security will come from the fact that experienced solidity developers will be developing the contracts, plus they will have another direct marketplace on Fabstir to auction to professional auditors, to audit their contracts. Thus, enhancing security even further and creating profitable marketplace for solidity developers to thrive. With Fabstir’s visual programming tool to plug and play audited, secure smart contracts together, to easily and rapidly build decentralised, secure apps and DAOs, business domain experts themselves can rapidly build directly the exact dapp that they require. Then they too can take their entire dapp and submit it to auditors for review. The tool has another benefit in that it shows visually how a dapp built with it works. All the flows of the tokens can be seen etc. Hence it won’t be a black box to non-coders looking to understand more, such as for investors of the dap. There will also be a selection of free smart contracts that come with the visual programming tool, that will allow the business domain experts to get started right away. Contracts will include NFT pools, fractionalised pools, time-locked vaults, the ability for each dapp to have governance and its own token by default and a lot more. Fabstir’s platform aims to be ideally suited to the new generation of decentralised applications that will be rapidly developed to take advantage of layer 2 solution on Ethereum and the upcoming sharding that will give much lower transaction fees and higher throughput, and that will usher in opportunities for many new use cases for dapps and DAOs. Fabstir aims to be at the forefront in supporting these new uses in for example; identity, governance, AI, other public goods, decentralised social media, next generation use cases for NFTs etc. The platform will be a safe, secure place for new, exciting dapps. Fees collected via Fabstir’s platform go to a results fund that then gets distributed to deserving projects in a retroactive public goods manner, further forwarding the open decentralised economy. Fabstir aims to be truly the DAO of DAOs. To have a secure, thriving platform for developers and businesses for all sorts of decentralised apps. With its visual programming tool and marketplaces, the intention is there to have no drawbacks in both security and speed of developing dapps.