I am struggling currently with finding the right implementation possibility for a token with the following properties:

  • Asset-backed token based on a non-fungible asset (like a piece of art)
  • More than one owner per token (crowd-ownership on each non fungible asset) e.g. multiple owners of one piece of art

A non fungible asset would lead into the direction of using ERC721 (which has been used e.g. by cryptokitties). The problem of this standard is that it would not allow multiple owners of a token because each token is not divisible.

I thought about multiple options but couldnt find out whether they are possible. For example would it be possible to have an ERC20 token "own" a ERC721?

Any suggestions?

  • Please be more detailed with your requirements and what you tried so far. You don’t need to post code but you do still need a specific question to get a specific answer. Like: what does own mean? What is the use case? How would you do this in the real world if computers didn’t exist? Commented Oct 21, 2018 at 14:21

2 Answers 2


The problem of this standard is that it would not allow multiple owners of a token because each token is not divisible.

Is there possibly confusion between the idea of divisibility and fractional ownership? They're quite different concerns.

Divisibility is about division. For example, you can divide $100 into two $50 but you wouldn't want to saw a kitty in two because that would be very bad for the cat. Still, joint ownership of a single kitty is possible.

It's true that ERC721 considers only a single owner. This is a common pattern that keeps the core standard and code compact but it doesn't prevent joint/fractional ownership, if that is what is needed.

The trick is that the "owner" could be a contract. That's up to you at an application-design level. You could put any sort of multi-signature or governance contract in place and give it custody of assets.

Take this specific contract from a multi-sig wallet client as an example: https://github.com/gnosis/MultiSigWallet/blob/master/contracts/MultiSigWallet.sol

Notice that owner is set to an address[] (array), which can include one, or more addresses. You could limit the max array size to include two addresses, or a hundred, it's up to you.

An implementation is then needed where two parties can send Ether to the multi-sig contract which purchases the NFT; The contract owns the NFT, and in turn any number of addresses in the address[] control the contract. Custom logic will be needed to determine how consensus takes place if one party wants to sell, etc.

Hope it helps.

  • can you suggest a guide or provide more details of how to set up joint/fractional ownership of a ERC 721 token.
    – jasan
    Commented Nov 5, 2018 at 10:00
  • The link provided is an excellent place to start and provides more than enough code to let you take your project in a number of directions. Just because solidity is executed on a blockchain does not mean it is dissimilar to any other language. Project directory structures still exists, there are config files, and libraries that contracts themselves can inherit from. There is nothing intrinsically different on the business logic side. Commented Jan 13, 2021 at 2:55

I'm really not an expert on different ERC possibilities out there, hopefully someone else can suggest you some alternative ERCs.

But, it all depends on what you wish to achieve. ERC721 is "just" a standard. You can come up with your own standard if you wish. The reason why using standards is encouraged is that one implementation is enough per standard - for example an exchange needs to implement functionality for ERC721 only once and after that all tokens which follow the standard can be handled with the same implementation.

So nothing stops you from creating whatever monster standards but you will have a hard time getting the standard recognized & implemented anywhere. For example you could just extend the ERC721 standard to add some extra required functionality.

It's an interesting idea for an ERC20 to "own" ERC721 but unfortunately I don't see how that could be possible. ERC20 can only own its own tokens.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.