3

I am trying to wrap my head around a specific scenario:

A company wants to leverage Ethereum's blockchain by storing, for example, hashes of documents and storing them on the network. The Idea is that once the data is published, the company has no access or control over it. How can this be accomplished?

My take/answer:

  1. Create a contract that stores variables (like a document hash) and then query when needed. Problem is, you'll need a contract account which has the contract. This will most likely be an account that the company owns in order to interact with the network. So, this method is not acceptable in this situation.

  2. Another option is to send desired data as transactions input/payload. Unless the transaction can be made to "the network" and the data can be retrieved by querying the network or account not owned by the company, then this approach won't work either. What I currently know, this is not possible.

Any takes on my answers and or ways to accomplish this for the given scenario? I'm not looking for plain answers but rather resources and guidance (though plain answers would be helpful too :p)

3

Problem is, you'll need a contract account which has the contract.

I think you are assuming that the creator of a contract is more important than they are. The creator of the contract does not have any special rights or abilities; once the contract is deployed it is its own separate entity that follows only the code that it was deployed with.

A contract is exactly what you need, and it is very simple to create a contract that acts as an append-only ledger where data can only be added and never changed or removed.

  • ahhh... You're right. For some reason I assumed that was the case. I'm guessing its due to the fact that I can create one in Ethereum Wallet and its automatically added to the contracts view. – Luv2Learn Jun 29 '17 at 13:22
2

This question is confusing. I think you might be bringing hidden assumptions into the picture.

Here's a starter concept.

  1. Make a contract to hold a list of documents.
  2. Everyone can see the list. It makes no difference who owns the contract. They can see it. Craft the contract so only the owner can change the data.
  3. Store documents "somewhere" and generate a hash.
  4. Send a transaction with the file location and hash to the contract.

IPFS gives you file location and hash in one step since any change to the file contents is also a change to the file name. hash(content) = file name.

Anyone can peruse the list of files held by the contract and fetch the files themselves.

Although the "owner" might be able to update the database in the contract, it is not possible (at best, not convenient) to hide this change from observers.

Hope it helps.

  • Apologies for confusing. Your starter concept is very clear and insightful however, step 2 is out of the picture. Ran this by the project proposer and insisted that wherever the hashes are stored, it is not in a contract or account that the company owns. Though it can be crafted as you mentioned, the company can lie and craft the contract differently. An example of the mindset of any skeptical person would have. – Luv2Learn Jun 27 '17 at 21:43
  • Also having a delegate company/account to store the contract is also out of the picture as is still leaves room for skepticism. – Luv2Learn Jun 27 '17 at 21:43
  • I don't want this thread to get too long, so feel free to reach out me privately. It's all about the use-case which isn't well understood. The solution above approximates how you store files and prove they originated from the company. If you're trying to prove something else, or open up access control in another way, that's a matter of design. In "Ethereum" != storage or possession. Indeed, the "owner" would be powerless to alter any of it. Again, useful, but only if that's the goal. – Rob Hitchens - B9lab Jun 28 '17 at 1:01

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

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