Topic: [ANN] Token0x - Ethereum 2.0 (Read 493 times)

1. The idea is not new, but with small changes, you are already using the old developments.
I heard only about DAICO from Vitalik Buterin. That's quite a different idea. If you know the same idea which was announced before please let me know.
Because it is easy to copy paste this idea and provide the statement about `this idea is not new`.
This idea came directly from my mind and is part of my mission. If you know somebody who has the same idea it means he also could have the same mission.

The mission is quite simple

Provide the passive income to people through technical revolution.
All members who participate should earn money and the all risks should be reduced as much is possible.

So I will repeat that this mission:
Provide the passive income to people through technical revolution.
Provide the passive income to people through technical revolution.
Provide the passive income to people through technical revolution.

Nothing wrong with this, if someone achieves it then everyone will win.

Not just founders who raise money and disappear.
Not just bounties who sell all `liked` tokens on the first day of exchange and drop the price.
Not just investors who try to find the project which closest to success and ignore another great project.

Everyone means everyone. If someone achieves it before me I will win as well. Because I will be able to invest my money and get the income.  
Currently, I CANNOT. Because I understand if I give million to someone he will play the game `do not touch me I have a dream already in my packet`
So please do not try to change my mind because I am pretty stable on it.  

2. But the market is not easy now, I would be surprised if you collect significant amounts without some kind of breakthrough novelties which you do not have yet.

Currently, I am focused to release the multi-currency (ethnamed) wallet because it gives me a network. Meanwhile, my team is building the community.
Also, I think I will do the prototype of Ethereum without any funds and possibly will make the ICO based on that model on Existent Ethereum with some limitations of course.

I will watch and monitor your progress.

Thank you. You can also watch Ethnamed. Because these projects are connected. I am pretty confident about market difficulty so try to make few releases to get enough power to run the Token0x network.

P.S. we are going to help one 3D team and provide our platform for their good project on the already built platform. I think it will also interesting for people.

They will understand our way of thinking.

The idea is not new, but with small changes you are already using the old developments. But the market is not easy now, I would be surprised if you collect significant amounts without some kind of breakthrough novelties which you do not have yet. I will watch and monitor your progress.

Thank you for explaining!!

Easy to understand use cases

1. Hacker protection
2. Human error protection

Complex in understanding use cases

1. ICO
2. Freelancer payments

So let's focus on complex in understanding


ICO

It is true, from the first look it is quite annoying but when people send money to ICO which is shut down all activities after 1 month is annoying too. And there is no way to force them to continue. It means the regulation is required here.
The regulation can be delegated to someone but we know what happens after - we create a centralized point of expertise (one step for next government)
So the solution is to change the protocol and let people play with trust levels.

Currently, the smart contract is a set of rules defined by a team
Should be, the sum of trust of all smart-contracts of all contributors.
But all these contributors still interact with smart-contract of the team.
So the team can give `award to trust` to people who set `0` refundable period and disallow to send higher refundable period for first transactions.
It helps to make the progress of the project and create a new trust lever for next contributors.

We do not remove 100 percent risks but reduce them.
Also, the team should not have any problem with that because they have to work. It does not work for cases when the team decide to withdraw money and disappear.


Freelancer payments

Each transaction needs gas
Each transaction stored in the blockchain

You want to hire a freelancer to make a design for you
You sent him 2 Non-Refundable ETH
You sent him 8 Refundable ETH which covers a working period
He has done his job
You refunded 8 Refundable ETH because you are a scammer

What we have finally

1. The evidence of the refunded transaction
2. 2 ETH insurance (could be configured during discussion)

If you receive the transaction from anonymous address then the evidence will not help but if the client binds the address with his website, the company then he binds this transaction with his reputation.
So freelancer should ask to bind the address with company address for better insurance.
 

Hm it clearly sounds interesting. But it is kind of funny how you are rewarding those people who actually don't use the refund system right? Since they are more trustable contributors. I think the refund system might be quite annoying for ICOs. I mean they HAVE TO wait 30 days after the contribution to make sure they can count on that contribution. A refund system would be great to somehow protect users against hackers like the phishing hack on Myetherwallet few months ago. But anything that can protect the users is good. I will follow this.

This is an innovative project, with POW meaning mining

How the mining part of the project would work ? Standard ETASH with pools ?

We can imagine all cases where this situation is possible

You hired somebody to make a work. He made it but you refunded all funds because you are a cheater.

Let's see what we have

1. You create the transaction
2. You create a refund transaction

2 transactions available in Blockchain.

This is a proof-of-refund for the address

You hire somebody to help you with your project. The project is available and has the own domain name.
It means you can use Ethnamed service to bind the Refundable Address with Domain Name to track the history.

When you start work with EXECUTER then EXECUTER can validate your history and define conditions with you.

In the case when you invested into the domain it is not profitable for you to reduce its reputation so EXECUTOR understands it as well before he starts.

In the case when EXECUTER is done his job and you refunded your funds the EXECUTOR is able to publish this information to your community.

Remember your community is able to refund transactions according to you as well because you established a trust-based relationship with them as well.

So your actions can provoke the community action.

It is not profitable for you to refund the transaction for the executed job and risk of cheating is reduced because you can lose your project.

P.S.

In the case when community decided to refund the transaction you will obtain your tokens back.

For the specific use cases you discuss it is good to have a refund option, but it also makes Token0x harder to use for commerce as you always have to wait for this time window to first close before the transaction can be deemed final. Could a malicious actor at a certain cost cause any damage to the network or do you have solutions in place for that? What if somebody decides to call a formerly valid transaction an error and cancels it in time?

It is easy to show some examples

Example 1


This is Ethnamed Contract in Standard Ethereum.  Nothing special

pragma solidity ^0.4.21; contract Ethnamed {             struct Name {         string record;         address owner;         uint256 expires;     }         address issuer = 0xad69f2ffd7d7b3e82605f5fe80acc9152929f283;         function changeIssuer(address _to) public {                 require(msg.sender == issuer);                 issuer = _to;             }         function withdraw(address _to) public {         require(msg.sender == issuer);                 _to.transfer(address(this).balance);     }         mapping (string => Name) registry;         function resolve(string _name) public view returns (string) {         return registry[_name].record;     }         function version() public pure returns (string) {         return "v0.001";     }         function transferOwnership(string _name, address _to) public {                 require(registry[_name].owner == msg.sender);                 registry[_name].owner = _to;     }     function removeExpiredName(string _name) public {                 require(registry[_name].expires < now);                 delete registry[_name];         }         function stringToUint(string s) pure internal returns (uint result) {         bytes memory b = bytes(s);         uint i;         result = 0;         for (i = 0; i < b.length; i++) {             uint c = uint(b);             if (c >= 48 && c <= 57) {                 result = result * 10 + (c - 48);             }         }     }         function setOrUpdateRecord(         string length,         string name,         string record,         string blockExpiry,         address owner,         uint8 v,         bytes32 r,         bytes32 s     ) public payable {                 require(stringToUint(blockExpiry) >= block.number);                 uint256 life = msg.value == 0.01  ether ?  48 weeks :                        msg.value == 0.008 ether ?  24 weeks :                        msg.value == 0.006 ether ?  12 weeks :                        msg.value == 0.002 ether ?  4  weeks :                        0;                                 require(life > 0);                 require(ecrecover(keccak256("\x19Ethereum Signed Message:\n", length, name, "r=", record, "e=", blockExpiry), v, r, s) == issuer);         require(registry[name].owner == msg.sender || registry[name].owner == 0x0);         registry[name].record = record;         registry[name].owner = owner;         registry[name].expires = now + life;         } }

Let's change it for Token0x Blockchian

pragma solidity ^0.4.21; contract Ethnamed {             struct Name {         string record;         address owner;         uint256 expires;     }         address issuer = 0xad69f2ffd7d7b3e82605f5fe80acc9152929f283;         function changeIssuer(address _to) public {                 require(msg.sender == issuer);                 issuer = _to;             }         function withdraw(address _to) public {         require(msg.sender == issuer);                 _to.transfer(address(this).balance);     }         mapping (string => Name) registry;         function resolve(string _name) public view returns (string) {         return registry[_name].record;     }         function version() public pure returns (string) {         return "v0.001";     }         function transferOwnership(string _name, address _to) public {                 require(registry[_name].owner == msg.sender);                 registry[_name].owner = _to;     }     function removeExpiredName(string _name) public {                 require(registry[_name].expires < now);                 delete registry[_name];         }         function stringToUint(string s) pure internal returns (uint result) {         bytes memory b = bytes(s);         uint i;         result = 0;         for (i = 0; i < b.length; i++) {             uint c = uint(b);             if (c >= 48 && c <= 57) {                 result = result * 10 + (c - 48);             }         }     }         function refund:setOrUpdateRecord(         string length,         string name,         string record,         string blockExpiry,         address owner,         uint8 v,         bytes32 r,         bytes32 s     ) public {                 registry[name].record = "";         registry[name].owner = 0x;         registry[name].expires = 0;         }     function setOrUpdateRecord(         string length,         string name,         string record,         string blockExpiry,         address owner,         uint8 v,         bytes32 r,         bytes32 s     ) public payable {                 require(msg.refundPeriod < 2 days);         require(stringToUint(blockExpiry) >= block.number);                 uint256 life = msg.value == 0.01  ether ?  48 weeks :                        msg.value == 0.008 ether ?  24 weeks :                        msg.value == 0.006 ether ?  12 weeks :                        msg.value == 0.002 ether ?  4  weeks :                        0;                                 require(life > 0);                 require(ecrecover(keccak256("\x19Ethereum Signed Message:\n", length, name, "r=", record, "e=", blockExpiry), v, r, s) == issuer);         require(registry[name].owner == msg.sender || registry[name].owner == 0x0);         registry[name].record = record;         registry[name].owner = owner;         registry[name].expires = now + life;         } }

We allow to set the refundPeriod on 2 days otherwise the transaction is reverted

require(msg.refundPeriod < 2 days);

We added the fund function which will be invoked automatically when the user decides to refund

function refund:setOrUpdateRecord(

The different that in this case, the developer cannot revert the transaction but he can make the refund logic



Example 2

Let's say you participate on ICO on standard Ethereum

function() payable {         bonus = 0;         uint256 tokens = exchangeRate(msg.value, bonus);         Token(tokenAddress).sell(msg.sender, tokens);     }

Let' see how we can make it in new blockchain

function() payable {         bonus = 0;         if(msg.refundPeriod == 0 days) {             bonus = 100; //award for trust         }                 if(msg.refundPeriod == 1 days) {             bonus = 50; //award for trust         }         if(msg.refundPeriod == 2 days) {             bonus = 30; //award for trust         }         uint256 tokens = exchangeRate(msg.value, bonus);         Token(tokenAddress).sell(msg.sender, tokens);     }

Also you can write the refund logic for it

function() refund {         bonus = 0;         if(msg.refundPeriod == 0 days) {             bonus = 100; //award for trust         }                 if(msg.refundPeriod == 1 days) {             bonus = 50; //award for trust         }         if(msg.refundPeriod == 2 days) {             bonus = 30; //award for trust         }         uint256 tokens = exchangeRate(msg.value, bonus);         //reverted transaction         Token(msg.sender).sell(tokenAddress, tokens);     }

I wrote the code only for demo case. I did not check it for possible mistakes

Not yet. Ethnamed protocol is implemented under the Ethereum blockchain.

It helped us to understand the problems of blockchain and think about a solution.

In case of Ethnamed you will be able to assign an email address to your ETH, BTC, ... addresses and send money in a human-readable way.

This project is proof-of-ability of the team to implement what we can would like to implement.

You can review our code, the way of thinking, etc.

If I understand correctly, once you send the payment you have the option to get a refund. That means you can use services and still ask for refund..or am I missing something?

The blockchain could be extremely dangerous as well

We are adding new financial properties and the ability to define rules for this property.

All rules can be defined in smart-contract and you will be able to review it before you start using it. Once you define it as dangerous for your case you can skip using it.

For instance, I would not prefer to keep million on EOS blockchain because of 21 Authorities - it could be dangerous. But I will keep some artifacts for games, etc there.

So we can think by analogy here.

You still can send ETH with 0 refundable period - in this case, you define your address has 100% trust to another address.
But also you can define the level of trust in cases where you do not 100% percent sure about the recipient.

Hey, Thank. Have seen your message in our telegram

If we want to change the protocol we have to make a new blockchain.

Pros:
  * In this case, we are able to change the Ethereum VM and add refund use case.
  * We are able to add Oracle Contract
  * We are able to ring signature algorithm for anonymous transactions
  * We are able to replace the blockchain with DAG in future
  * Legally Ok
Cons:
  * Need to build a miner network


It is possible in some case to implement the functionality in the current Ethereum.

Pros:
  * Faster to do the refundable ETH
Cons:
  * No Oracle
  * No Refund Smart-Contract Logic
  * Need to prove that it is not security token
  * No DAG. Have to follow Ethereum development way

So, we consider the new blockchain for now but we want to keep this question of open for our community

If the name quoted Ethereum 2.0 will then be created a new block chain or will ETH be used to create the tokens and future smart contracts?

wait, wont there be any major security concerns, like if the refunding thing is compromised, it could be extremley dangerours

Do they also have a refund option? How it works?

You can also see our other product - http://ethnamed.io - Crypto Paypal. Naming Service and Multi-Currency Wallet
http://wallet.ethnamed.io

If the things you said are true, this would be a good project, but I would like to know who works for this project, which is very important.

where i can find a members of team? i interesting how many people works with security this platform. because it's very important to this project!