Shipit ist Lieferung von Paketen
der nächsten Generation
Shipit ist eine Gemeinschaft von Mitreisenden, eine mobile Anwendung, die Reisende und Absender von Paketen, die unterwegs sind, vereinigt.
Privatverkauf Bonus bis zu 55% Mai 01—August 31
Vorverkauf Bonus bis zu 35% September 01—September 30
Öffentlicher Verkauf Bonus bis zu 15% Oktober 01—Oktober 31
Privatverkauf —
Mai 01—August 31. 2018
Bonus — 55%
-
tage
-
std
-
protokoll
-
sekunden
1 2 5 5
Participants in Whitelist
Join our Whitelist

Das ist die erste ähnliche Anwendung mit Smart Сontracts und Blockchain als ein natives Werkzeug, das das Leben der Menschen weltweit erleichtern kann. Aufgrund der Blockchain wollen wir transparente und sichere Beziehungen zwischen den Teilnehmern der Prozesse sehen.

Mit den steigenden Preisen für Kurierdienste bietet Shipit die Möglichkeit, Pakete weltweit billiger und sicherer zu versenden. Paketversand war nie so einfach und zugänglich

Whitepaper
download pdf file, 12,3 mb
What is ShipIt?
Shipit verifiziert die Benutzer und kontrolliert alle Pakete, um den Versandprozess zu sichern. Die interaktive Schnittstelle ermöglicht einfaches und schnelles Versenden. Der Benutzer hat sich keine Sorgen um das Weglassen wichtiger Details zu machen.
Für Absender
  1. Mache eine Bestellung!
  2. Plane ein Treffen mit dem Reisenden!
  3. Gib die Tracking-Nummer ein und verfolge dein Paket online!
  4. Erfahre über die Paketzustellung!
  5. Zahl für die Zustellung!
Für Reisende
  1. Wähle eine Bestellung aus!
  2. Plane ein Treffen mit dem Absender!
  3. Kommuniziere mit dem Absender in Echtzeit!
  4. Stell das Paket zu!
  5. Erhalte die Bezahlung!
Probleme des Markts für Kurier-, Express- und Paketdienste
  • Der Versand ist zu teuer
  • Verzögerte Lieferzeiten
  • Wahrscheinlichkeit, dass das Paket verlorengeht oder beschädigt wird
Warum ist der Paketversand so teuer?
Große Geschäftsausgaben Transport - und Kurierunternehmen sind dazu gezwungen, Tausende Einheiten von Technik und das Personal zu halten.
Benennung Anteil am Weltmarkt in % Anzahl der Mitarbeiter Luftverkehr (eigene und gemietete Luftfahrzeuge). Autoverkehr (eigene und gemietete Fahrzeuge).
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
Andere 11%
Tatsache: „Um ein Paket mit Dokumenten von Moskau nach New York zu versenden, muss man mehr als 200 Dollar zahlen. Dabei ist der Preis für diese Dokumente nicht mehr als $20 „
Warum wird die Lieferzeit verzögert?
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%
Tatsache: „Nach einem Bericht von Mintel waren 15% der britischen Kurierdienstkunden mit Verletzung der Lieferfristen und langen Lieferzeiten bei der Paketzustellung konfrontiert.“
Warum gehen Pakete verloren oder werden beschädigt?
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
Tatsache: „Nach einem Bericht von Mintel sind 10 von 100 britischen Kurierdienstkunden mit dem Verlust oder der Beschädigung von Paketen konfrontiert.“
Sharing Economy
steht für Zukunft
Die Sharing Economy ist eine von zehn Ideen, die die Welt in den nächsten zehn Jahren verändern wird. Das ist ein neues sozioökonomisches Modell, das unseren Konsum von Waren und Dienstleistungen revolutionieren sollte.
TIME Magazine
Und wenn in einigen Kategorien bereits große Führer erschienen sind, zum Beispiel bei Reisen Airbnb und in Carsharing ZarCar, so dann fängt sich der Markt in der Kategorie „Crowd Shipping“ an erst zu formen. Mit jedem Jahr erhalten Start-ups, die die Sharing Economy Branche entwickeln, immer mehr Finanzierung.
Jahr 2007 2010 2013 2016
Anzahl der Unternehmen, die Investitionen erhalten haben 40 85 271 420
Gesamtinvestitionsgröße, $ Milliarden 0,04 0,13 1,74 23,4
Einkommen der Unternehmen, $ Milliarden 2 5,5 15 41
Gründe für die Popularität
der Sharing Economy
55% Urbanisierung
der Bevölkerung
63% Verbreitung
des Internets
48% Smartphone-
Verbreitung
12% Wachstum des Anteils
der Mittelschicht
Buy tokens
Technologien
  • Smart Сontracts und Blockchain
  • Krypto-Wallet
  • Einlagen
  • Factoring
  • Paketweiterleitungsservice
Smart Сontracts werden Systembenutzer vereinigen und Ihre Arbeit verantwortlicher machen, denn die gesamte Geschichte der Aktivitäten der Benutzer wird in Blockchain aufgezeichnet werden, und es können in Zukunft keine Änderungen gemacht werden.
Wie das funktioniert Ergebnis
Benutzerprofile Die Blockchain wird die Geschichte des Benutzers transparent machen. Benutzeraktionen werden verantwortungsvoller.
Automatisierung Smart contracts werden die Automatisierung und Absicherung der Prozesse ermöglichen. Fehler und Datenmanipulationen sind ausgeschlossen.
Sicherheit Alle persönlichen Benutzerdaten werden in einem Hash aufgezeichnet. Der Benutzer-Hash ist nicht identifizierbar auch, wenn er weggenommen wird.
Die bestehenden Fiat-Zahlungsmethoden bereiten bestimmte Schwierigkeiten und verhindern die Skalierung der App. Man wird von einigen staatlichen Strukturen erzwungen, langwierige teure und bürokratische Prozeduren durchlaufen zu müssen, um die Anwendung für die Einwohner verschiedener Länder zahlen zu lassen. Daher ist die Schaffung einer Krypto-Wallet und eigener Kryptowährung die beste Lösung für diese Frage.
Reason Ergebnis
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.
Die Einführung von Einlagen ermöglicht es, Pakete von Absendern gegen Diebstahl, Verlust und Beschädigung zu versichern. Nach Meinung von Reisenden und Absendern ist es ein berechtigter Entschluss. Die Absender verstehen, dass sie im Falle höherer Gewalt eine entsprechende Entschädigung erhalten und die Reisenden verstehen, dass sie im Falle von rechtswidrigen Aktivitäten keine Einlage zurückbekommen, sie können nicht mehr verdienen und vom System ausgeschlossen werden.
Für Absender Die Einführung von Einlagen ermöglicht es, Pakete von Absendern gegen Diebstahl, Verlust und Beschädigung zu versichern.
Für Reisende Im Falle von rechtswidrigen Aktionen bekommen Reisende keine Einlage zurück. Sie können nicht mehr verdienen und können aus dem System ausgeschlossen werden.
Das Factoring löst das Problem der Deckung der Geldkosten für das Paket, das der Reisende bezahlen muss, um Gegenstände, die er zum Zustellen erhält, gegen Verlust und Schäden zu versichern. Shipit zahlt eine Einlage für den Reisenden, indem seine Risiken versichert werden. Der Reisende bezahlt nur Factoring-Dienstleistungen.
Paketweiterleitungsservice ist Einkauf von Waren im Ausland durch einen Vermittler und mit weiterem Versand von Paket an Kunden. Ausländische Online-und offline-Shops können sich von denen, die in Ihrem Land sind, durch günstigere Preise unterscheiden. Die Preise können niedriger und das Angebot viel breiter sein. Viele ausländische Marken können überhaupt nicht vertreten sein. Deshalb können die gewünschten Waren mithilfe von Paketweiterleitungsservice gekauft werden.
Wie das funktioniert:
  1. Der Kunde macht eine Bestellung in Shipit mit ausführlicher Beschreibung des gewünschten Artikels.
  2. Shipit findet einen Reisenden, der in Ihre Region fliegt.
  3. Der Kunde zahlt eine Einlage plus macht eine Bezahlung für den Reisenden.
  4. Der Reisende kauft die Waren und geht in die Region des Kunden.
  5. Der Reisende übergibt die Ware an den Kunden.
  6. Shipit überweist Geld für Waren plus Bezahlung an den Reisenden.
  7. Shipit erhält eine Provision.
Vorteile des Paketweiterleitungsservice von Shipit:
  • Der Lieferpreis ist 1,5–3 mal niedriger.
  • Möglichkeit, Waren weltweit zu kaufen.
  • Zugang zu exklusiven in Ihrer Region nicht vorhandenen Waren.
  • Die Lieferung erfolgt schneller als eine normale Lieferung.
  • Servicequalität und Sicherheit auf höchstem Niveau.

Sicherheit

Das Shipit-Entwicklungsteam verbrachte Dutzende Stunden, um Komponenten und Prozesse, die mit nationalen und internationalen Transporten verbunden sind, zu optimieren. Das Ziel der Anwendung ist, einen einfachen, sicheren, schnellen und zuverlässigen Paketversand zu ermöglichen und eine zusätzliche Verdienstmöglichkeit anzubieten. Bei der Entwicklung der Anwendung wurde besonderer Wert auf die Sicherheit unserer Benutzer gelegt. Wir müssen sicher sein, dass alle Aktivitäten, die durch Shipit durchgeführt werden, nicht gegen gesetzliche Regelungen zum Transport verstoßen, und Gegenstande, die transportiert werden, allen nationalen und internationalen Anforderungen entsprechen.

Whitepaper

Hauptmerkmale des Projekts

Join now
Vorteile
Lassen Sie Reisende Ihr Paket zustellen!
  • Courier services
  • Crowd services
  • Crowdshipping services
  • Crowdsourced logistics
DHL Fedex UPS USPS
Preis $60 $261 $163-$220 $166-$224 $90
Lieferzeit 5 Tage
und weniger
1—3
Werktage
5—7
Werktage
7
Werktage
21
Werktage
Zuverlässigkeit und Bequemlichkeit
  • Zuverlässige und geprüfte Kuriere
  • Chat, Rezensionen und Bewertungen, Einlagen und Code-Sicherheitssystem sind integriert.
  • Pakete können im Zoll länger bleiben
  • Kein internationaler Versand von Benutzer zu Benutzer (P2P)
  • Beschränkungen für bestimmte Paketarten
  • Pakete können im Zoll länger bleiben
  • Kein internationaler Versand von Benutzer zu Benutzer (P2P)
  • Beschränkungen für bestimmte Paketarten
  • Pakete können im Zoll länger bleiben
  • Kein internationaler Versand von Benutzer zu Benutzer (P2P)
  • Beschränkungen für bestimmte Paketarten
  • Paketverfolgung nach Grenzübertritt kann nicht möglich sein
  • Pakete gehen verloren, werden am Zoll oder bei der Post beschädigt und gestohlen.
Uber BlaBlaCar Gett Delivery
Crowdshipping Ja Optional Optional Ja
Transportmöglichkeiten Fahrzeuge, Motorräder, Züge, Flugzeuge Fahrzeuge Fahrzeuge Fahrzeuge
Durchschnittliche Begrenzung der Lieferdistanz mehr als 500 km weniger als 500 km weniger als 500 km weniger als 500 km
Benutzerprofile auf der Blockchain Ja Nein Nein Nein
Einlagen und Versicherung für wertvolle Pakete (opt) Ja Nein Nein Nein
PiggyBee AirMule Hitchit
Interactive map
Mobile app
Verification of travelers
Verification of senders
Reviews on blockchain platform
Preliminary monitoring of shipments
Safe payments
Cryptocurrency payments
Smart contracts
Digital safety systems
Mail forwarding
Crowdsource Logistics
Courier Logistics
Less Trust
More Trust
3 Gründe, um Shipit
ab heute zu lieben
Coole Gemeinschaft Wir unterstützen uns gegenseitig und kontrollieren Qualität der Dienstleistungen, die von Teilnehmern unserer Plattform angeboten werden. Alle Benutzer werden verifiziert, um sicher zu sein, wem Sie Ihr Paket anvertrauen.
Praktisch Das Modell von Crowdsource und Sharing Economy hat seine Relevanz, Popularität und Effizienz nachgewiesen. Bald wird Shipit zu einer üblichen Anwendung in jedem Smartphone. Werde Teil einer neuen Geschichte.
Effizient und kostengünstig Egal, wo immer Sie sind, Sie finden immer Mitreisende und Reisende, die Ihnen helfen, das Paket zu liefern. Versende Pakete einfach über Tausende von Kilometern weltweit und spare an Paketzustellung.
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 ist ein Schritt in die Zukunft der Expresslieferungen. Nimm an Token Sale teil!

55% Bonus
Join now