​Shipit -la livraison de
colis nouvelle génération
Shipit – est une communauté de compagnons de voyage, une application mobile qui met en rassemble les voyageurs et les expéditeurs de colis, ayant le même trajet.
Private Sale Prime jusqu’à 55% 1 mai—31 août
Pre Sale Prime jusqu’à 35% 1 septembre—30 septembre
Public Sale Prime jusqu’à 15% 1 octobre—31 octobre
Private Sale —
1 mai—31 août 2018
Réduction — 55%
-
journées
-
heures
-
minutes
-
secondes
1 2 8 1
Participants in Whitelist
Join our Whitelist

C'est la première application de ce type utilisant les smart contracts et le Blockchain, en tant qu'outil de base pouvant faciliter la vie aux gens du monde entier. En nous appuyant sur le Blockchain, nous pourrons voir des relations transparentes et protégées entre les participants aux processus.

Avec la croissance des prix des services postaux, Shipit offre la possibilité d'envoyer des colis partout dans le monde moins cher et plus sûr. L’expédition de colis n'a jamais été aussi facile et accessible.

Papier blanc
download pdf file, 12,3 mo
What is ShipIt?
Shipit vérifie les utilisateurs et modère tous les colis sécurisant le processus d'expédition L'interface interactive rend l'expédition facile et rapide. L'utilisateur peut ne pas s'inquiéter de l'omission de tout détail important.
Espace expéditeurs
  1. Passer une commande
  2. Planifier une rencontre avec un voyageur
  3. Suivre le colis sur le tracker
  4. En savoir plus sur la livraison
  5. Payer pour l'expédition
Espace voyageurs
  1. Choisir une application
  2. Planifier une rencontre avec l'expéditeur
  3. Communiquer avec l'expéditeur en temps réel
  4. Livrer le paquet
  5. Être payé
​Problèmes du marché des livraisons du courrier et de petits colis
  • Expédition trop chère
  • Longs délais
  • Probabilité de dégât et de perte de colis
Pourquoi envoyer un colis est si cher?
Dépenses opérationnelles considérables. Les entreprises de logistique et de courrier sont contraintes d’avoir des milliers d'équipements et du personnel.
Titre Part du marché mondial,% Nombre d’employés Transport aérien (propre et loué), unités. Transport automobile(propre et loué), unités.
DHL 38% 508 000 188 76 000
Fedex Corp 24% 400 000 657 58 000
UPS 22% 268 000 657 86 000
TNT 5% 56 000 56 30 000
Autres 11%
Fait réel. "Pour envoyer un colis de documents papier de Moscou à New York il faut payer plus de 200 $. Alors que le prix de ces documents ne dépasse plus de 20 $"
Pourquoi le délai de livraison est-il long?
Transit hubsDelivery services often cannot ship a parcel directly from one point to another.
BureaucracyParcels are often processed by customs and postal systems.
IntermediariesCourier and delivery companies are sometimes forced to rely on third party services.
15%
Fait réel. "Selon un rapport de Mintel, 15% des clients britanniques du service de messagerie ont été confrontés à des irrégularités et de longs délais d'attente pour la livraison des colis."
Pourquoi les colis sont-ils perdus ou endommagés?
TheftCustoms, courier and postal services' employees steal shipments.
Absence of personal responsibility Customs, courier and postal services' employees treat shipments irresponsibly and with negligence.
10/100
Fait réel. "Selon un rapport de Mintel, 10 clients sur 100 du service de messagerie britannique ont été confrontés à la perte ou à la détérioration des colis."
​ L’avenir et pour la "Sharing
Economy" et crowdshipping
"L’économie de consommation collective est l'une des dix idées qui vont changer le monde dans les 10 prochaines années, un nouveau modèle socio-économique qui devrait révolutionner notre consommation de biens et de services."
Revue TIME Magazine
Dans certaines catégories, il y a déjà de grands leaders, par exemple, dans les voyages c’est Airbnb, dans l’autopartage c’est ZipCar, mais dans la catégorie crowdshipping, le marché commence à peine à se former. Chaque année, les start-ups qui développent l'industrie de la "sharing economy" reçoivent de plus en plus de financement.
An 2007 2010 2013 2016
Nombre d'entreprises ayant reçu des investissements 40 85 271 420
Investissements totaux, en milliards de dollars 0,04 0,13 1,74 23,4
Revenu des entreprises, en milliard de $ 2 5,5 15 41
Les raisons de la popularité
de la "sharing economy"
55% Urbanisation de
la population
63% Utilisation de
l’Internet
48% Lancement des
smartphones
12% Croissance de la
part de la classe moyenne
Buy tokens
​Technologies
  • Smart contracts et blockchain
  • Crypto portefeuille
  • Dépôts de caution
  • Affacturage
  • Mail forwarding
Les smart contracts vont unir les utilisateurs du système et rendre leur travail plus responsable, car tout l'historique de l'activité des utilisateurs sera enregistré dans le Blockchain et ne fera pas l'objet de modifications à l'avenir.
Comment ça marche? Résultat
Profiles Le Blockchain rendra l'historique de l'utilisateur transparent. Les actions des utilisateurs deviendront plus responsables.
Automatisation Les smart contracts automatisent et sécurisent les processus. Les erreurs et les falsifications de données sont éliminées.
Sécurité Toutes les données personnelles des utilisateurs sont indiquées dans le hachage d’utilisateur. Si le hachage de l'utilisateur est supprimé, il sera toujours possible de l'identifier.
Les méthodes de paiement financier existantes créent certaines barrières et empêchent la mise à l'échelle de l'application. Certaines structures d’État sont obligées de subir des procédures longues, coûteuses et bureaucratiques pour permettre à l’application de payer les résidents de différents pays. Par conséquent, la création d'un portefeuille et de sa propre crypto monnaie est la meilleure solution à cette question.
Reason Résultat
Freedom
of payments
International banking transactions between citizens of diffirent countries may be unavailable due to bureaucracy and sanctions. Cryptocurrencies are not easy to regulate. This allows paying a traveler in any cryptocurrency.
Convenient
conversion
To convert fiat currency user needs to execute several excessive transactions. User can execute a payment in any way they find convenient by converting fiat to crypto in the app.
Quick payments Fiat transactions may take a long time and get delayed. Faster processed cryptocurrencies would allow to execute almost instant transactions.
L’insertion des dépôts de caution permettra d’assurer les colis des expéditeurs contre le vol, la perte et les dommages. C'est une solution justifiée du point de vue des expéditeurs et des voyageurs. Les expéditeurs comprennent qu'en cas de force majeure, ils recevront une compensation adéquate, et les voyageurs comprennent qu'en cas d'actions illégales, ils ne recevront pas d'acompte, ils ne pourront pas gagner d'argent et pourront être exclus du système.
Espace expéditeurs L’insertion des dépôts de caution permettra d’assurer les colis des expéditeurs contre le vol, la perte et les dommages.
Espace voyageurs En cas d'actions illégales, les voyageurs ne recevront pas le dépôt de caution. Ils ne pourront pas gagner d'argent et peuvent être exclus du système.
Dans le concept Shipit l’affacturage résout le problème de la couverture de la valeur monétaire du colis, que le voyageur doit payer pour assurer les articles reçus en main propre contre la perte et les dommages. Shipit fait un dépôt de caution pour le voyageur assurant ses risques. Le voyageur ne paie que pour les services d'affacturage.
Mail forwarding - l’achat des marchandises à l'étranger par un intermédiaire, avec expédition ultérieure du colis au client. Les magasins étrangers en ligne et hors ligne peuvent être différents de ceux de votre pays. Les prix peuvent être plus bas, et la gamme est beaucoup plus large. Plusieurs marques étrangères peuvent ne pas être représentées dans vos magasins. Par conséquent, vous pouvez acheter les marchandises désirées à l'aide des services Mail forwarding
Comment ça marche?:
  1. Le client crée une commande sur Shipit avec une description détaillée du produit souhaité.
  2. Shipit trouve un voyageur qui vole vers votre région.
  3. Le client fait un dépôt de caution plus une récompense au voyageur.
  4. Le voyageur achète les marchandises et se rend dans la région du client.
  5. Le voyageur transmet les marchandises au client.
  6. Shipit transfère la somme d'argent pour les marchandises et récompense le voyageur.
  7. Shipit perçoit une commission
Avantages du Mail forwarding de Shipit:
  • Le prix d'expédition est de 1,5-3 fois plus bas.
  • Possibilité d'acheter des produits du monde entier.
  • Accès aux exclusivités inaccessibles dans votre région.
  • La vitesse de livraison est plus élevée que la livraison habituelle.
  • Qualité du service et sécurité au plus haut niveau.

Sécurité

L'équipe de développement de Shipit a passé des dizaines d'heures à optimiser les composants et les processus associés au transport international. Le but de l'application est de fournir un moyen facile, sûr, rapide et fiable d'envoyer des colis et la possibilité de gagner de l'argent sur leur transport. Un accent particulier de développement a été mis aux problèmes de sécurité de nos utilisateurs. Nous devons être sûrs que toutes les activités effectuées à travers le Shipit ne violent pas les règles de transport, et que les articles transportés correspondent aux normes internationales requises.

Papier blanc

Caractéristiques principales

Join now
​Avantages
Permettre au voyageur de livrer un colis
  • Courier services
  • Services Crowdsource
  • Services Crowdshipping
  • Crowdsourced logistics
DHL Fedex UPS USPS
Prix $60 $261 $163-$220 $166-$224 $90
Délai de livraison 5 jours
et/ou moins
1—3
jours ouvrables
5—7
jours ouvrables
7
jours ouvrables
21
jours ouvrables
Fiabilité et commodité
  • Des transporteurs fiables vérifiés
  • Chat intégré, avis et commentaires, dépôts et système de sécurité au code
  • Les colis peuvent être retardés à la douane
  • Aucun envoi international de l'utilisateur à l'utilisateur (P2P)
  • Il y a des restrictions d’expédition de colis
  • Les colis peuvent être retardés à la douane
  • Aucun envoi international de l'utilisateur à l'utilisateur (P2P)
  • Il y a des restrictions d’expédition de colis
  • Les colis peuvent être retardés à la douane
  • Aucun envoi international de l'utilisateur à l'utilisateur (P2P)
  • Il y a des restrictions d’expédition de colis
  • Le suivi du colis après le franchissement de la frontière peut ne pas être disponible
  • Les colis peuvent être perdus, endommagés et volés à la douane ou au bureau de poste
Uber BlaBlaCar Gett Delivery
Crowdshipping oui optionnel optionnel oui
Opportunités de transport Véhicules, Motocycles, Trains, Avions Véhicules Véhicules Véhicules
Limite moyenne de distance d'expédition plus de 500 km moins de 500 km moins de 500 km moins de 500 km
Profiles des utilisateurs sur Blockchain oui non non non
Système de dépôts et d'assurance des parcelles de valeur (opt) oui non non non
PiggyBee AirMule Hitchit
Carte interactive
Application mobile
vérification des personnalités transporteurs
vérification des personnalités des expéditeurs
Commentaires sur Blockchain
Vérification préliminaire des colis par les modérateurs
Paiement sécurisé
Paiement en crypto monnaie
Smart contracts
Système de sécurité au code
Mail forwarding
Crowdsource Logistics
Courier Logistics
Less Trust
More Trust
​ 3 raisons d'aimer
Shipit aujourd'hui
Super communauté Nous nous soutenons mutuellement et contrôlons la qualité des services fournis par les participants de notre plateforme. Tous les utilisateurs sont vérifiés afin d'être sûr de ceux à qui vous confiez le colis.
Pratique Le modèle crowdsource et la "sharing economy" a prouvé sa pertinence, sa popularité et son efficacité. Dans un avenir très proche, Shipit deviendra une application reconnue dans tous les smartphones. Devenir une partie de la nouvelle histoire
Efficace et économique Peu importe où vous êtes, vous trouverez toujours des compagnons de route et des voyageurs qui vous aideront à livrer le colis. Envoyez facilement des colis à des milliers de kilomètres dans le monde entier et économisez sur les frais de port.
Join Our Telegram
Token Distribution
  • 75%Token Sale
  • 15%Team
  • 5%Partners and advisors
  • 5%Bounty campaign
Token Sale Funds Allocation
  • 37%Development, product
    improvement and technical perfecting
  • 55%Marketing and advertising
  • 5%Legal
  • 3%Other
Smart contract
                    
pragma solidity ^0.4.19;
/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/179
*/
contract ERC20Basic {
    function totalSupply() public view returns (uint256);
    function balanceOf(address who) public view returns (uint256);
    function transfer(address to, uint256 value) public returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
}
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract ERC20 is ERC20Basic {
    function allowance(address owner, address spender) public view returns (uint256);
    function transferFrom(address from, address to, uint256 value) public returns (bool);
    function approve(address spender, uint256 value) public returns (bool);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
    /**
    * @dev Multiplies two numbers, throws on overflow.
    */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }
        uint256 c = a * b;
        assert(c / a == b);
        return c;
    }
    /**
    * @dev Integer division of two numbers, truncating the quotient.
    */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // assert(b > 0); // Solidity automatically throws when dividing by 0
        // uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold
        return a / b;
    }
    /**
    * @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
    */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        assert(b <= a);
        return a - b;
    }
    /**
    * @dev Adds two numbers, throws on overflow.
    */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        assert(c >= a);
        return c;
    }
}
/**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/
contract BasicToken is ERC20Basic {
    using SafeMath for uint256;
    mapping(address => uint256) balances;
    uint256 totalSupply_;
    /**
    * @dev total number of tokens in existence
    */
    function totalSupply() public view returns (uint256) {
        return totalSupply_;
    }
    /**
    * @dev transfer token for a specified address
    * @param _to The address to transfer to.
    * @param _value The amount to be transferred.
    */
    function transfer(address _to, uint256 _value) public returns (bool) {
        require(_to != address(0));
        require(_value <= balances[msg.sender]);
        balances[msg.sender] = balances[msg.sender].sub(_value);
        balances[_to] = balances[_to].add(_value);
        emit Transfer(msg.sender, _to, _value);
        return true;
    }
    /**
    * @dev Gets the balance of the specified address.
    * @param _owner The address to query the the balance of.
    * @return An uint256 representing the amount owned by the passed address.
    */
    function balanceOf(address _owner) public view returns (uint256 balance) {
        return balances[_owner];
    }
}
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
contract StandardToken is ERC20BasicToken {
    mapping (address => mapping (address => uint256)) internal allowed;
    /**
    * @dev Transfer tokens from one address to another
    * @param _from address The address which you want to send tokens from
    * @param _to address The address which you want to transfer to
    * @param _value uint256 the amount of tokens to be transferred
    */
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
        require(_to != address(0));
        require(_value <= balances[_from]);
        require(_value <= allowed[_from]‌[msg.sender]);
        balances[_from] = balances[_from].sub(_value);
        balances[_to] = balances[_to].add(_value);
        allowed[_from]‌[msg.sender] = allowed[_from]‌[msg.sender].sub(_value);
        emit Transfer(_from, _to, _value);
        return true;
    }
    /**
    * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
    *
    * Beware that changing an allowance with this method brings the risk that someone may use both the old
    * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
    * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
    * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
    * @param _spender The address which will spend the funds.
    * @param _value The amount of tokens to be spent.
    */
    function approve(address _spender, uint256 _value) public returns (bool) {
        allowed[msg.sender]‌[_spender] = _value;
        emit Approval(msg.sender, _spender, _value);
        return true;
    }
    /**
    * @dev Function to check the amount of tokens that an owner allowed to a spender.
    * @param _owner address The address which owns the funds.
    * @param _spender address The address which will spend the funds.
    * @return A uint256 specifying the amount of tokens still available for the spender.
    */
    function allowance(address _owner, address _spender) public view returns (uint256) {
        return allowed[_owner]‌[_spender];
    }
    /**
    * @dev Increase the amount of tokens that an owner allowed to a spender.
    *
    * approve should be called when allowed[_spender] == 0. To increment
    * allowed value is better to use this function to avoid 2 calls (and wait until
    * the first transaction is mined)
    * From MonolithDAO Token.sol
    * @param _spender The address which will spend the funds.
    * @param _addedValue The amount of tokens to increase the allowance by.
    */
    function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
        allowed[msg.sender]‌[_spender] = allowed[msg.sender]‌[_spender].add(_addedValue);
        emit Approval(msg.sender, _spender, allowed[msg.sender]‌[_spender]);
        return true;
    }
    /**
    * @dev Decrease the amount of tokens that an owner allowed to a spender.
    *
    * approve should be called when allowed[_spender] == 0. To decrement
    * allowed value is better to use this function to avoid 2 calls (and wait until
    * the first transaction is mined)
    * From MonolithDAO Token.sol
    * @param _spender The address which will spend the funds.
    * @param _subtractedValue The amount of tokens to decrease the allowance by.
    */
    function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
        uint oldValue = allowed[msg.sender]‌[_spender];
        if (_subtractedValue > oldValue) {
            allowed[msg.sender]‌[_spender] = 0;
        } else {
            allowed[msg.sender]‌[_spender] = oldValue.sub(_subtractedValue);
        }
        emit Approval(msg.sender, _spender, allowed[msg.sender]‌[_spender]);
        return true;
    }
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
    address public owner;
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    /**
    * @dev The Ownable constructor sets the original `owner` of the contract to the sender
    * account.
    */
    function Ownable() public {
        owner = msg.sender;
    }
    /**
    * @dev Throws if called by any account other than the owner.
    */
    modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }
    /**
    * @dev Allows the current owner to transfer control of the contract to a newOwner.
    * @param newOwner The address to transfer ownership to.
    */
    function transferOwnership(address newOwner) public onlyOwner {
        require(newOwner != address(0));
        emit OwnershipTransferred(owner, newOwner);
        owner = newOwner;
    }
}
contract SHPT is OwnableStandardToken  {
    string public constant name = "Shipit Token";
    string public constant symbol = "SHPT";
    uint8 public constant decimals = 8;
    uint256 public constant INITIAL_SUPPLY = (500 * (10**6)) * (10 ** uint256(decimals));
    constructor() public {
        totalSupply_ = INITIAL_SUPPLY;
        balances[this] = INITIAL_SUPPLY;
        emit Transfer(address(0), this, INITIAL_SUPPLY);
    }
    //отправка токенов, с адреса контракта
    function send(address to, uint amount) public onlyOwner {
        require(to != address(0));
        require(amount > 0);
        // SafeMath.sub will throw if there is not enough balance.
        balances[this] = balances[this].sub(amount);
        balances[to] = balances[to].add(amount);
        emit Transfer(this, to, amount);
    }
    //эмиссия токенов и перевод на указанный адрес
    function mint(address to, uint amount) public onlyOwner {
        require(to != address(0));
        require(amount > 0);
        totalSupply_ = totalSupply_.add(amount);
        balances[to] = balances[to].add(amount);
        emit Transfer(address(0), to, amount);
    }
    //сожжение токенов с указанного адреса
    function burn(address from, uint amount) public onlyOwner {
        require(from != address(0));
        require(amount > 0);
        // SafeMath.sub will throw if there is not enough balance.
        totalSupply_ = totalSupply_.sub(amount);
        balances[from] = balances[from].sub(amount);
        emit Transfer(from, address(0), amount);
    }
    function() public payable {}
    //отправка эфира
    function sendEther(address to, uint amount) public onlyOwner {
        require(to != address(0));
        require(amount > 0);
        to.transfer(amount);
    }
}

Shipit : un pas en avant dans la livraison express Participer au Tokensale!

55% Réduction
Join now