Shipit - consegna dei
pacchi di nuova generazione
Shipit è una comunità di compagni di viaggio, un’applicazione mobile che unisce viaggiatori e mittenti di pacchi che vanno nello stesso posto.
Vendita privata Bonus fino a 55% 1 maggio—31 agosto
Prevendita Bonus fino a 35% 1 settembre—30 settembre
Vendita pubblica Bonus fino a 15% 1 ottobre—31 ottobre
Vendita privata —
1 maggio—31 agosto 2018
Bonus — 55%
-
giorni
-
ore
-
minuti
-
secondi
1 2 5 5
Participants in Whitelist
Join our Whitelist

Questa è la prima applicazione simile che utilizza il contratto intelligente (smart contract) e la blockchain come strumento nativo che può facilitare la vita delle persone in tutto il mondo. Basandosi sulla blockchain vogliamo vedere un rapporto trasparente e sicuro tra i partecipanti dei processi.

Con la crescita dei prezzi su servizi di corrieri, Shipit offre la possibilità di spedire i pacchi in tutto il mondo in modo più economico e sicuro. Spedizione dei pacchi non è mai stata più semplice e accessibile.

Carta bianca
download pdf file, 12,0 mb
What is ShipIt?
Shipit verifica gli utenti e monitora tutti i pacchi rendendo sicuro il processo di spedizione. L’interfaccia interattiva rende l’invio facile e veloce. Non c’è bisogno di preoccuparsi dell’omissione di qualche dettaglio importante.
Mittente
  1. Posta la tua richiesta
  2. Pianifica un incontro con un viaggiatore
  3. Rintraccia il pacco usando il tracker
  4. Chiedi informazioni sulla consegna
  5. Paga per la consegna
Viaggiatore
  1. Seleziona la richiesta
  2. Pianifica un incontro con il mittente
  3. Comunica con il mittente in tempo reale
  4. Consegna il pacco
  5. Ricevi il pagamento
Problemi del mercato delle consegne di corrieri e di piccoli pacchi
  • Spedizione molto costosa
  • Termini molto lunghi
  • Possibilità di danneggiamento e smarrimento del pacco
Perché la spedizione di un pacco è così costosa?
Costi operativi elevati Compagnie di trasporto e corrieri sono obbligati a mantenere migliaia di pezzi di attrezzature e il personale.
Nome Quota del mercato mondiale, % Numero personale Trasporto aereo (proprio e affittato), unità Trasporto automobilistico (proprio e affittato), unità
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
Other 11%
Fatto: “Per spedire un pacchetto di documenti cartacei da Mosca a New York è necessario pagare più di $200. Allo stesso tempo, il prezzo di questi documenti non supererà i $20”
Perché i termini di consegna vengono ritardati?
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%
Fatto: “Secondo il rapporto della società Mintel, 15% dei clienti britannici di servizi di corriere hanno dovuto affrontare la violazione dei termini e l’attesa lunga di consegna di pacchi.”
Perché i pacchi vengono smarriti o danneggiati?
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
Fatto: “Secondo il rapporto della società Mintel, 10 su 100 clienti britannici di servizi di corriere hanno dovuto affrontare la perdita o il danneggiamento di pacchi.”
La sharing economy e crowd
shipping sono il futuro
«L’economia del consumo condiviso è una delle dieci idee che cambieranno il mondo nei prossimi 10 anni, un nuovo modello socio-economico che deve rivoluzionare il nostro consumo di beni e servizi.»
Rivista TIME Magazine
In alcune categorie vediamo già l’emergersi di grandi leader, ad esempio, Airbnb nei viaggi e ZipCar nello car sharing, ma nella categoria di crowd shipping il mercato sta ancora iniziando a formarsi. Ogni anno, le startup che sviluppano il settore di sharing economy ottengono sempre più finanziamenti.
Anno 2007 2010 2013 2016
Numero di aziende che hanno ricevuto investimenti 40 85 271 420
L’importo totale degli investimenti, miliardi di $ 0,04 0,13 1,74 23,4
Reddito di aziende, miliardi di $ 2 5,5 15 41
Ragioni della popolarità
della sharing economy
55% Urbanizzazione
della popolazione
63% Diffusione
Internet
48% Diffusione
smartphone
12% Aumento quota
classe media
Buy tokens
Tecnologie
  • Contratti intelligenti e blockchain
  • Cripto-portafoglio
  • Depositi
  • Factoring
  • Mail forwarding
I contratti intelligenti uniranno gli utenti del sistema e renderanno il loro lavoro più responsabile, perché l’intera cronologia delle attività degli utenti verrà registrata nella blockchain e potrà essere modificata in futuro.
Come funziona Risultato
Profili Blockchain rende la cronologia dell’utente trasparente. Utenti più responsabili.
Automazione Contratti intelligenti permettono di automatizzare e proteggere i processi. Assenza di errori e di manipolazione di dati.
Sicurezza Tutti i dati personali degli utenti vengono registrati nell’hash. Impossibilità di identificare l’hash nonostante la sua rimozione.
I metodi di pagamento fiduciario esistenti creano alcuni ostacoli e problemi di scalabilità dell’applicazione. Alcune strutture statali costringono a sottoporsi a procedure lunghe, costose e burocratiche per consentire le transazioni dell’app con residenti di diversi paesi. Ecco perché la creazione di un portafoglio e di una valuta crittografica propria è una soluzione ottima.
Reason Risultato
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’introduzione di depositi consentirà di assicurare i pacchi dei mittenti contro furti, smarrimento e danneggiamenti. Questa è una soluzione giustificata dal punto di vista di mittenti e viaggiatori. I mittenti capiscono che in caso di forza maggiore loro riceveranno un risarcimento adeguato, e i viaggiatori capiscono che in caso di azioni illegali non riceveranno un deposito, non guadagneranno e possono essere esclusi dal sistema.
Per i mittenti Depositi consentono di assicurare i pacchi dei mittenti contro furti, smarrimento e danneggiamenti.
Per i viaggiatori In caso di azioni illegali, deposito non verrà restituito ai viaggiatori. Non potranno guadagnare e possono essere esclusi dal sistema.
Factoring risolve il problema di copertura del valore monetario del pacco, che il viaggiatore deve pagare per assicurare contro la perdita e il danneggiamento degli oggetti ricevuti. Shipit mette il deposito per il viaggiatore assicurando i suoi rischi. Il viaggiatore paga solo i servizi di factoring.
Mail forwarding è l’acquisto di beni all’estero da parte dell’intermediario, con la successiva spedizione del pacco al cliente. I negozi esteri online e offline possono differenziarsi in modo conveniente da quelli del vostro Paese. I prezzi possono essere inferiori ma la gamma molto più ampia. Molte marche estere potrebbero non essere rappresentate affatto. Pertanto, è possibile acquistare i prodotti desiderati usando i servizi di mail forwarding.
Come funziona:
  1. Il cliente crea la richiesta nell’app Shipit con una descrizione dettagliata del prodotto desiderato.
  2. Shipit trova un viaggiatore che vola nella regione del cliente.
  3. Il cliente effettua un deposito più una ricompensa al viaggiatore.
  4. Il viaggiatore acquista il prodotto e va nella regione del cliente.
  5. Il viaggiatore consegna il prodotto al cliente.
  6. Shipit trasferisce i soldi per il prodotto più la ricompensa al viaggiatore.
  7. Shipit riceve una commissione.
Shipit mail forwarding advantages:
  • Il prezzo di consegna è 1,5-3 volte inferiore.
  • La possibilità di acquistare qualsiasi prodotto in tutto il mondo.
  • Accesso ai prodotti in esclusiva inaccessibili nella regione del cliente.
  • La velocità di consegna è superiore alla consegna normale.
  • Massimo livello di qualità del servizio e sicurezza.

Sicurezza

Il team di sviluppo di Shipit ha impiegato decine di ore per ottimizzare i componenti e i processi associati ai trasporti internazionali. Lo scopo dell’app è quello di fornire un modo facile, sicuro, veloce e affidabile di spedizione dei pacchi e la possibilità di guadagnare denaro trasportandoli. Una attenzione particolare è stata prestata alla sicurezza di nostri utenti. Dobbiamo essere sicuri che tutte le attività svolte attraverso l’app Shipit siano il linea con le regole di trasporto e che gli articoli trasportati siano conformi agli standard internazionali richiesti.

Carta bianca

Caratteristiche principali

Join now
Vantaggi
Consenti ai viaggiatori di consegnare il vostro pacco
  • Courier services
  • Servizi crowdsource
  • Servizi crowdshipping
  • Crowdsourced logistics
DHL Fedex UPS USPS
Prezzo $60 $261 $163-$220 $166-$224 $90
Tempo di consegna non oltre i
5 giorni
1—3
giorni lavorativi
5—7
giorni lavorativi
7
giorni lavorativi
21
giorni lavorativi
Affidabilità e convenienza
  • Viaggiatori affidabili e verificati
  • Chat integrato, recensioni e revisioni, depositi e sistema di sicurezza a codice
  • Formalità doganali possono causare ritardi di consegna dei pacchi
  • Non ci sono spedizioni internazionali da utente a utente (P2P)
  • Restrizioni per tipi di pacchi
  • Formalità doganali possono causare ritardi di consegna dei pacchi
  • Non ci sono spedizioni internazionali da utente a utente (P2P)
  • Restrizioni per tipi di pacchi
  • Formalità doganali possono causare ritardi di consegna dei pacchi
  • Non ci sono spedizioni internazionali da utente a utente (P2P)
  • Restrizioni per tipi di pacchi
  • La tracciabilità può essere impossibile dopo che un pacco ha attraversato il confine
  • I pacchi vengono smarriti, danneggiati e rubati alla dogana
Uber BlaBlaCar Gett Delivery
Crowdshipping Optional Optional
Opportunità di trasporto Automobili, Moto, Treni, Aerei Automobili Automobili Automobili
Limite della distanza di spedizione media più di 500 km meno di 500 km meno di 500 km meno di 500 km
Profili degli utenti su blockchain No No No
Sistema depositi e assicurazione di pacchi preziosi (opzionale) No No No
PiggyBee AirMule Hitchit
Mappa interattiva
Applicazione mobile
Verifica viaggiatori
Verifica mittenti
Recensioni su blockchain
Verifica preliminare dei pacchi da parte dei moderatori
Pagamento sicuro
Pagamento con valuta criptata
Contratti intelligenti
Sistema di sicurezza a codice
Mail forwarding
Crowdsource Logistics
Courier Logistics
Less Trust
More Trust
3 ragioni per iniziare
ad amare Shipit oggi
Una comunità fantastica Ci sosteniamo a vicenda e monitoriamo la qualità dei servizi forniti dai partecipanti della nostra piattaforma. Tutti gli utenti passano la verifica per creare fiducia e garantire la trasparenza.
Comodo Il modello сrowdsource e sharing economy ha dimostrato la sua rilevanza, popolarità ed efficacia. Molto presto l’app Shipit sarà installata su ogni smartphone. Diventa parte di una nuova storia.
Efficiente e conveniente Ovunque tu sia, potrai sempre trovare qualcuno che possa fare una consegna per te. Spedisci il pacco a oltre 1000 km e risparmia il denaro.
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 passo verso il futuro delle consegne espresse. Partecipa a TokenSale!

55% Bonus
Join now