ERC20 and/or ERC721

Question

Consider the following scenario. A person owns a asset called "A". Now the asset is very high valued and unique but you can allow other persons to own a certain part of that asset.

• EDIT: Ownership can be claimed iff certain funds are raised as decided by the owner. Like a crowdsale but for ownership . Hope it makes sense

At first I thought about ERC721 but then how can I divide it so that I can send a piece to each interested person?

Ideas I came across so far:

1. Create a ERC721 token and wrap it in ERC20 token and then distribute them
2. Create a simple ERC721 token with added function of totalSupply to mint multiple of them
3. Send the same ERC721 token to multiple persons and keep track of who owns them
4. Creating a simple ERC20 token and keep limited supply but I can't figure out how to keep them unique.
5. Any standards that might be implementing this and I might be unaware

I am looking for ideas/answers/is this even possible?/would any of the above ideas work? type of thing and all suggestions are welcomed. If you think something is missing, let me know and I can edit the question as well to better suite the responses. Thank you all in advance.

• EDIT-2: After digging in this area, came across this on reddit - https://www.reddit.com/r/etherscan/comments/7wgcc8/fractional_ownership_of_erc721_tokens/.

Any suggestions on how to implement this kind of thing as it matches a lot with my requirements

• EDIT-3 : Came across this and would like to know is it a viable solution or not https://github.com/ethereum/eips/issues/1155

Answer 1

I would be inclined to make a token factory that issues ERC20 shares. The shares in A would be fungible and you would have another contract for B.

You would probably want a way to track them, the contracts, symbols, desc and so on. ERC721 is a candidate by there is nothing to "transfer" in the reference list itself so I would probably just build it into a purpose-built contract factory.

Presenting the shares as tokens is good news for wallets, DeX, transfers, and a simple factory would keep track of them and form the basis for a dApp UI.

A candidate alternative is EIP1155 - https://blog.enjincoin.io/erc-1155-the-final-token-standard-on-ethereum-a83fce9f5714. It would do what you want and with less gas but it would be a bet on future adoption and wallet/exchange support.

You could make a happy median with a custom ERC20 implementaton deployed as a minimal proxy contract which could be very cheap if you optimize for that.

Hope it helps.

Answer 2

You're not the first one to have such a question. Here's one reference: Ethereum implementation of a non-fungible but divisible token? (ERC721 seems not to work for that) . The first answer there suggest that the token can be owned by a contract which should actually solve your problem - you just have to code the owning contract in a certain way.

There are also some EIPs for such thing but I don't think they've gained much traction. Here's something I stumbled upon: https://github.com/ethereum/EIPs/issues/1528