Why

Blockchain technology speeds up transactions Between certified companies and validity not all actions.

TRANSPARENCY

PRIVACY

SAFE & ROBUST

UNMANIPULABLE

COMPLIANCE

TRACEABILITY

FULL KYC

ETHICS & SOCIAL

REPORT FINGERPRINT

Every time a payment is made, the system generates a new payment fingerprint using a third party to ensure that if someone steals the credentials he could never use them.

sign(public key,fingerprint hash)

User

Shop

KYC Riddle

Payment

Check last fingerprint

Register new fingerprint

CHECK FINGERPRINT

In order to validate any payment, users need to provide their public keys as well as their last used fingerprint and, once the payment is validated, new identification data will be generated for next transactions. This prevents anyone from being able to use your identity or using your credentials

Teios id + get public key

Search last fingerprint registered

Validate signature

Validate fingerprint longitude

Gen new keypair & save keypair + last

OK

KYC RIDDLE

The riddles with third party data used by the system generate a fingerprint that changes in each payment and validate more reliably the identify of any person.

Google Maps

Social

Private Escrow

Goverment Certificate

AUTHENTICATION FLOW

ID Point

Facebook

G+

Shop Payment

Google Maps

Linkedin


ID Point

Thief

Prohibited

Download TEIOS wallet

Save your TEIOS coins in your favorite plattform, MAC, Android, Windows, Linux .

Android

Ios

Linux

Windows

Tools

Search in all our blockchain blocks, transactions and addresses. Join to TEIOS mining plattform and contribute to the network development

Explorer

Status.

    
function status(uint256 sellAmount, uint256 buyAmount) private {

    //stablish the buy price & sell price with the spread configured in the contract

    buyPrice=(this.balance/totalSupply);
    sellPrice=buyPrice-(buyPrice*spread)/100;

    //add to the panic counter the amount of sell or buy
    panicBuyCounter=panicBuyCounter+buyAmount;
    panicSellCounter=panicSellCounter+sellAmount;

    //get the block numer to compare with the last block
    uint reset=block.number;

    //compare if happends enougth time between the last and the current block with the contract configuration
    if((reset-lastBlock)>=(panicTime/15)){
        //if the time is more than the panic time we reset the counter for the next checks
        panicBuyCounter=0+buyAmount;
        panicSellCounter=0+sellAmount;
        //aisgn the new last block
        lastBlock=block.number;
    }

    //activate or desactivate panic mode
    panic(0);
}
    

Vote.

    
function vote(
    uint proposalNumber,
    bool supportsProposal,
    string justificationText
)
    onlyMembers
    returns (uint voteID)
{
    Proposal p = proposals[proposalNumber];         // Get the proposal
    if (p.voted[msg.sender] == true) throw;         // If has already voted, cancel
    p.voted[msg.sender] = true;                     // Set this voter as having voted
    p.numberOfVotes++;                              // Increase the number of votes
    if (supportsProposal) {                         // If they support the proposal
        p.currentResult++;                          // Increase score
            } else {                                        // If they don't
            p.currentResult--;                          // Decrease the score
    }
    // Create a log of this event
    Voted(proposalNumber,  supportsProposal, msg.sender, justificationText);
    return p.numberOfVotes;
}
    

New proposal.

    
function newProposal(
    address beneficiary,
    uint etherAmount,
    string JobDescription,
    bytes transactionBytecode
)
    onlyMembers
    returns (uint proposalID)
{
    proposalID = proposals.length++;
    Proposal p = proposals[proposalID];
    p.recipient = beneficiary;
    p.amount = etherAmount;
    p.description = JobDescription;
    p.proposalHash = sha3(beneficiary, etherAmount, transactionBytecode);
    p.votingDeadline = now + debatingPeriodInMinutes * 1 minutes;
    p.executed = false;
    p.proposalPassed = false;
    p.numberOfVotes = 0;
    ProposalAdded(proposalID, beneficiary, etherAmount, JobDescription);
    numProposals = proposalID+1;

    return proposalID;
}
    

Buy.

    

//set min token price
function setMinPrice(uint256 minprice ) onlyOwner {
    minPrice=minprice;
}

function buy() payable {

    //exetute if is allowed by the contract rules
    if(keccak256(buyLock)!=keccak256("close")){
        if (frozenAccount[msg.sender]) throw; // Check if frozen

        if(buyPrice < minPrice) {
        buyPrice=minPrice;
    }

    if (msg.sender.balance < msg.value) throw; // Check if the sender has enought eth to buy
    if (msg.sender.balance + msg.value < msg.sender.balance) throw; //check for overflows

    uint dec=decimals;

    uint amount = (msg.value / buyPrice)*(10**dec) ; // calculates the amount

    if (amount <= 0) throw;  //check amount overflow
    if (balanceOf[msg.sender] + amount < balanceOf[msg.sender]) throw; // Check for overflows
    if (balanceOf[this] < amount) throw; // checks if it has enough to sell

    balanceOf[this] -= amount; // subtracts amount from seller's balance
    balanceOf[msg.sender] += amount; // adds the amount to buyer's balance

    Transfer(this, msg.sender, amount); //send the tokens to the sendedr
    //update status variables of the contract
    status(0,msg.value);
    }else{
        throw;
    }

}
    

Sell.

    
function sell(uint256 amount) {

    //exetute if is allowed by the contract rules
    if(keccak256(sellLock)!=keccak256("close")){
    if (frozenAccount[msg.sender]) throw; // Check if frozen
    uint dec=decimals;
    if (balanceOf[this] + amount < balanceOf[this]) throw; // Check for overflows
    if (balanceOf[msg.sender] < amount ) throw; // checks if the sender has enough to sell

    if(sellPrice < minPrice) {
    sellPrice=minPrice-(minPrice*spread)/100;

}

    balanceOf[msg.sender] -= amount*(10**dec); // subtracts the amount from seller's balance
    balanceOf[this] += amount*(10**dec); // adds the amount to owner's balance
// Sends ether to the seller. It's important


    if (!msg.sender.send(amount*sellPrice)) {
        throw; // to do this last to avoid recursion attacks
    } else {
        // executes an event reflecting on the change
        Transfer(msg.sender, this, amount*(10**dec));
        //update contract status
        status(amount*sellPrice,0);
    }
    }else{throw;}
}