Shipit 是下一代包裹运送
Shipit 是同路人的团体,手机应用,连接同路的旅行者和包裹发件人。
Unfortunately, Shipit Token Sale has been cancelled.
All contributions have been refunded. To read more, please, visit our blog

这是第一个类似的采用了智能合约和区块链的应用,作为帮助全世界的人们让生活变得更简单的本土工具。在区块链的基础上我们想看到透明的和受到保护的过程参与者之间的关系。

随着快递服务费的增长,Shipit 提供了世界范围内运送包裹更加实惠和安全的机会。包裹运送还从未如此简单和普遍。

白纸
download pdf file, 10.8 mb
What is ShipIt?
Shipit对用户进行身份核实并将慢化所有包裹,让发货过程安全。互动接口让发货变得简单快速。用户不用为错过任何重要的细节感到担忧。
对发货人
  1. 分配申请表
  2. 计划与旅行者见面
  3. 根据跟踪器跟进包裹物流
  4. 得知货到
  5. 支付送货费
对旅行者
  1. 选择申请表
  2. 计划与寄件人见面
  3. 与寄件人现时交流
  4. 包裹送达
  5. 收钱
快递和小型包裹派送市场的问题
  • 运费太贵
  • 时间长
  • 包裹可能损坏和丢失
为什么包裹运费这么贵?
运作支出大。交通运输和快递公司不得不雇用上千个员工和技术单位。
名称 世界市场份额,% 员工数量 航空交通工具(自己的和租赁的),单位。 陆路交通工具(自己的和租赁的),单位。
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
其他 11%
实例: “为了从莫斯科向纽约发送文件包裹需要200美元以上。同时这些文件的价格不超过20美元。
为什么运送时间这么长?
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%
实例: “根据Mintel公司计算,快递服务的15%英国客户遇到过逾期和长时间等待包裹派送的问题”。
为什么包裹会丢失或者遭到损坏?
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
实例: “根据Mintel公司的计算,100个快递服务的英国客户有10个遇到过包裹丢失或者损坏”。
共享经济和人群运输的未来
“共享经济-这是近10年来改变世界的十大思想之一,新的社会-经济模式,可以改革我们的商品和服务需求”。
时代杂志
在部分行业已经出现了龙头,例如,在旅行方面Airbnb,而在汽车共享方面有ZipCar,但在人群运输领域市场才刚刚形成。每年发展共享经济产业的创业公司获得越来越多的融资。
2007 2010 2013 2016
获得投资的公司数量 40 85 271 420
投资总额,十亿美元 0,04 0,13 1,74 23,4
公司收入,十亿美元 2 5,5 15 41
共享经济流行的原因
55% 人口城市化
63% 网络的普及
48% 智能手机普及
12% 中层阶级增长
Buy tokens
技术
  • 智能合约和区块链
  • 加密钱包
  • 押金
  • 托收信贷
  • 海外代购
智能合约将系统用户联合起来并更加负责地完成工作,因为用户活动的任何情况将在区块链几率下来并且在将来不能被改变。
这是怎么进行的 结果
简介 区块链将用户记录变得透明。 用户的行为变得更加负责。
慢化 智能合约将过程慢化和保障安全。 排除了信息不足和错误。
安全 所有用户的个人信息都记录在散列。 无论怎样也不可能鉴别出用户的散列。
现有的法定货币支付方式造成了一些阻碍并且妨碍应用扩大。一些国家结构不得不进行长期,昂贵和官僚主义的过程,这让应用可以给各个国家的居民支付。所以创建钱包和私人加密货币是更好的对这一问题的解决方案。
Reason 结果
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.
实行押金制度保障了发货人的包裹免于被盗,丢失和损坏。这对发货人和旅行者而言是可靠的方案。发货人明白,在不可抗力因素的情况下他们会获得合理的补偿,而旅行者明白,在违法行为的情况下不会返还他们押金,也就无法挣外快并且可能会被踢出系统。
对于发货人而言 押金可以保障发货人的包裹以防被盗,丢失和损坏。
对于旅行者而言 在违法行为的情况下不会讲押金还给旅行者。他们不可以挣外快并且将被踢出系统。
托收信贷解决本应由旅行者承担的包裹价值押金的问题,以便避免收到的物件丢失和损失。Shipit 为旅行者承担押金和风险。旅行者只需支付托收信贷的服务费。
海外代购-由中间商在境外购买商品,接着将包裹发给订购者。国外线上和线下商店都比您的国家商店出售得实惠。价格更低,并且品种多得多。许多海外品牌并不是到处都可以购买得到。因此买到心仪的商品可能需要海外代购服务。
这是怎么进行的:
  1. 订购者在Shipit创建详细描述心仪商品的申请。
  2. Shipit寻找去往您的地区的旅行者。
  3. 订购者支付旅行者货款和酬金。
  4. 旅行者购买商品并发到订购者所在地区。
  5. 旅行者将商品转交给订购者。
  6. Shipit将货款和酬金转给旅行者。
  7. Shipit获得手续费。
Shipit海外代购的优点:
  • 运货价格低1.5-3倍。
  • 可以购买世界上任何商品。
  • 获得在您所在地区没有的独家商品。
  • 运送速度比普通运送更快。
  • 服务态度和安全性达到最高水平。

安全

Shipit研发团队用了几十个小时,将与国际运输相关的过程和部分最优化。应用的目的-保证轻松,安全,快速和可靠的放松包裹方式和在派送过程中挣钱的机会。研发的特别支点是解决我们用户的安全问题。我们应该相信,通过Shipit实现的整个活动没有违反运输规则,而运输的物件符合国际标准的要求。

白纸

关键特点

Join now
优势
允许旅行者运送您的包裹
  • Courier services
  • Crowd services
  • Crowdshipping services
  • Crowdsourced logistics
DHL Fedex UPS USPS
价格 $60 $261 $163-$220 $166-$224 $90
送达时间 5
天和更少
1—3
个工作日
5—7
个工作日
7
个工作日
21
个工作日
可靠性和便利
  • 可靠的经过检测的运送者
  • 创建对话,反馈和看法,押金和安全密码系统
  • 包裹可能在海关滞留。
  • 从用户到用户没有国际发送(P2P)
  • 包裹类型有限制
  • 包裹可能在海关滞留。
  • 从用户到用户没有国际发送(P2P)
  • 包裹类型有限制
  • 包裹可能在海关滞留。
  • 从用户到用户没有国际发送(P2P)
  • 包裹类型有限制
  • 在过境后可能无法进行包裹物流跟踪
  • 包裹在海关或者邮寄分点丢失,损坏和被盗
Uber BlaBlaCar Gett Delivery
Crowdshipping 可选 可选
交通机遇 汽车
摩托车
火车
飞机
汽车 汽车 汽车
送货距离的平均限制 小于500千米 大于500千米 大于500千米 大于500千米
区块链用户的简介
押金系统和贵重包裹保险(可选)
PiggyBee AirMule Hitchit
互动卡
手机应用
送货人个人信息核实
发货人个人信息的核实
区块链的反馈
由减速器进行包裹提前检测
安全支付
用加密货币支付
智能合约
安全密码系统
海外代购
Crowdsource Logistics
Courier Logistics
Less Trust
More Trust
今天立刻爱上Shipit的三个理由
一流的团体 我们相互支持并跟进我们平台参与者提供的服务质量。所有的用户进行身份核实,以便放心您将包裹交给谁的手上。
方便 人群资源和经济共享模式证明了自己的需求量,热度和高效性。近来Shipit在每一台智能手机成为了流行的应用。成为新篇章的一部分。
高效又实惠 无论您在哪您都可以找到可以帮您送达包裹的同路人和旅行者。世界范围内上千公里的路程轻松派发包裹并且邮费实惠。
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-这是迈向运输快递未来的一部。加入代币销售吧!

55%折扣
Join now