參與藝術品上鏈，鑒定，交易包含了下面幾種角色。

所以我們需要為不同的角色提供不同的App應用。

用戶端：功能包括防偽查詢，鏈上資產的瀏覽，權益轉讓，資產拍賣，資產抵押，社區互動，分享，數字資產行情，錢包等等

機構端：負責信息收集，信息整理，數據提交，數據審查，資產上鏈，資產劃撥等等

鑒定師：負責數字資產的鑒定，需要有相關資質。

舉例，書畫怎樣做防偽

以國畫為例，我們首先找一個宣紙企業合作，在宣紙生產過程中，將NFC晶片夾在宣紙中間，然後我們使用螢光油墨在宣紙上印刷防偽圖案。也可以採用人民幣上的金屬絲方案，最後拍攝紙紋。視頻記錄下藝術家的整個作畫過程，然後再拍攝特徵數據。最後使用激光打孔技術，在宣紙上打出防偽圖案數據，針孔極小肉眼難以分辨，每個防偽數據都是唯一的。

NFC 標籤可以使用易碎紙粘貼在藝術品上，缺點是壽命較短。使用PVC材料又容易撕下。

油畫可以講NFC晶片放在紡織布中，使用堆彩技術的畫家可以講NFC晶片覆蓋（埋植）在顏料下面

傳統藝術品投資門檻非常高，一是用戶不知道從哪些渠道可以投資，二是藝術品價值過高，三是藝術品鑒定難。這導致了投資藝術品門檻過高。 Token 能實現份額化，實現人人參與，人人持有，P2P交易。

例如某機構上鏈一件藝術品，用戶可以投資該藝術品的一定份額，可以轉讓他持有的權益。且交易去中心化，不受任何機構，管理者的制約。

下面的合約可以展示如何分割藝術品份額，最終達到鏈上資產的份額分割和持有與交易。

		
pragma solidity ^0.4.25;

/**
 * @title SafeMath
 * @dev Math operations with safety checks that revert on error
 */
library SafeMath {

  /**
  * @dev Multiplies two numbers, reverts on overflow.
  */
  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
    // benefit is lost if 'b' is also tested.
    // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
    if (a == 0) {
      return 0;
    }

    uint256 c = a * b;
    require(c / a == b);

    return c;
  }

  /**
  * @dev Integer division of two numbers truncating the quotient, reverts on division by zero.
  */
  function div(uint256 a, uint256 b) internal pure returns (uint256) {
    require(b > 0); // Solidity only automatically asserts 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 c;
  }

  /**
  * @dev Subtracts two numbers, reverts on overflow (i.e. if subtrahend is greater than minuend).
  */
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    require(b <= a);
    uint256 c = a - b;

    return c;
  }

  /**
  * @dev Adds two numbers, reverts on overflow.
  */
  function add(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a + b;
    require(c >= a);

    return c;
  }

  /**
  * @dev Divides two numbers and returns the remainder (unsigned integer modulo),
  * reverts when dividing by zero.
  */
  function mod(uint256 a, uint256 b) internal pure returns (uint256) {
    require(b != 0);
    return a % b;
  }
}        

contract Ownable {
    
    address public owner;
    
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    
    constructor() public {
        owner = msg.sender;
    }
    
    modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }
    
    function transferOwnership(address newOwner) public onlyOwner {
        require(newOwner != address(0));
        emit OwnershipTransferred(owner, newOwner);
        owner = newOwner;
    }

}

contract NetkillerAssetsToken is Ownable {
    using SafeMath for uint256;
    
    string public name;
    string public symbol;
    uint public decimals;
    uint256 public totalSupply;
    
    mapping(address => mapping(string => uint256)) internal balances;
    mapping(string => address) internal tokens;
    
    event Transfer(address indexed _from, address indexed _to, string indexed _tokenId);
    event Burn(address indexed from, string _tokenId);
    
    constructor(
        string tokenName,
        string tokenSymbol,
        uint decimalUnits
    ) public {
        owner = msg.sender;
        name = tokenName;
        symbol = tokenSymbol; 
        decimals = decimalUnits;
        totalSupply = 0; 
    }
    
    function add(address _owner, string _tokenId) onlyOwner returns(bool status){
        balances[_owner][_tokenId] = 100 * 10 ** uint256(decimals);
        tokens[_tokenId] = _owner;
        totalSupply = totalSupply.add(1);
        return true;
    }
    
    function balanceOf(address _owner, string _tokenId) constant returns(uint balance){ 
        return balances[_owner][_tokenId];
    }

    function ownerOf(string _tokenId) constant returns (address owner) {
        return tokens[_tokenId];
    }
    
    function transfer(address _to, string _tokenId){
        
        address _from = msg.sender;
        uint256 amount = balances[_from][_tokenId];
        transfer(_to, amount, _tokenId);
    }
    function transfer(address _to, uint256 _value, string _tokenId){
        require(msg.sender == ownerOf(_tokenId));
        require(msg.sender != _to);
        require(_to != address(0));
        
        address _from = msg.sender;
        uint256 amount = balances[_from][_tokenId];
        require(amount >= _value);
        
        balances[_from][_tokenId] = balances[_from][_tokenId].sub(_value);
        balances[_to][_tokenId] = balances[_to][_tokenId].add(_value);
        tokens[_tokenId] = _to;

        emit Transfer(_from, _to, _tokenId);
    }
    
    function burn(address _owner, string _tokenId) onlyOwner public returns (bool success) {
        require(balances[_owner][_tokenId] > 0 && balances[_owner][_tokenId] == 100 * 10 ** uint256(decimals));

        balances[_owner][_tokenId] = 0;
        tokens[_tokenId] = address(0);

        totalSupply = totalSupply.sub(1);
        emit Burn(msg.sender, _tokenId);
        return true;
    }
    
}		
		
		

由於 ERC721 不太符合我的需求，所以我結合 ERC20 和 ERC721 寫出了我的合約。合約儘量保持了ERC20的使用習慣，函數定義儘量兼容 ERC20。

我們來看下面的構造方法，每個種類的物品一個合約，例如字畫，陶瓷，青銅器。

		
    constructor(
        string tokenName,
        string tokenSymbol,
        uint decimalUnits
    ) public {
        owner = msg.sender;
        name = tokenName;
        symbol = tokenSymbol; 
        decimals = decimalUnits;
        totalSupply = 0; 
    }
		
		

通過下面函數，添加資產到 Token，使鏈上資產與Token綁定。

		
    function add(address _owner, string _tokenId) onlyOwner returns(bool status){
        balances[_owner][_tokenId] = 100 * 10 ** uint256(decimals);
        tokens[_tokenId] = _owner;
        totalSupply = totalSupply.add(1);
        return true;
    }		
		
		

balances[_owner][_tokenId] = 100 * 10 ** uint256(decimals); 初始化份額是 100 表示 100%

totalSupply = totalSupply.add(1); 物品件數加一。可以用於統計鏈上資產的數量。

下面函數是查詢資產的持有人

		
function ownerOf(string _tokenId) constant returns (address owner) {
        return tokens[_tokenId];
    }		
		
		

下面函數是，權益轉讓和權益份額轉讓。

		
    function transfer(address _to, string _tokenId){
        
        address _from = msg.sender;
        uint256 amount = balances[_from][_tokenId];
        transfer(_to, amount, _tokenId);
    }
    function transfer(address _to, uint256 _value, string _tokenId){
        require(msg.sender == ownerOf(_tokenId));
        require(msg.sender != _to);
        require(_to != address(0));
        
        address _from = msg.sender;
        uint256 amount = balances[_from][_tokenId];
        require(amount >= _value);
        
        balances[_from][_tokenId] = balances[_from][_tokenId].sub(_value);
        balances[_to][_tokenId] = balances[_to][_tokenId].add(_value);
        tokens[_tokenId] = _to;

        emit Transfer(_from, _to, _tokenId);
    }		
		
		

接下來，我們就是可以開發 Dapp 錢包了，在錢包中實現資產的轉移交易。

這個合約可以移植到 EOS 上，Hyperledger Fabric 不可以，因為 Fabric 沒有鎖的機制，會導致計算出錯。

我們希望資產上鏈適用於任何領域，後面也方便將業務拓展。所以我實現了一個萬能合約。以不變應萬變，Hyperledger Fabic 鏈碼如下。

		
package main

import (
	"fmt"
	"github.com/hyperledger/fabric/core/chaincode/shim"
	pb "github.com/hyperledger/fabric/protos/peer"
)

type SmartContract struct {}

func (s *SmartContract) Init(stub shim.ChaincodeStubInterface) pb.Response {
	return shim.Success(nil)
}

func (s *SmartContract) Query(stub shim.ChaincodeStubInterface) pb.Response {
	return shim.Success(nil)
}

func (s *SmartContract) Invoke(stub shim.ChaincodeStubInterface) pb.Response {

	// Retrieve the requested Smart Contract function and arguments
	function, args := stub.GetFunctionAndParameters()
	// Route to the appropriate handler function to interact with the ledger appropriately
	if function == "create" {
		return s.create(stub, args)
	} else if function == "find" {
		return s.find(stub, args)
	} else if function == "update" {
		return s.update(stub, args)
	} else if function == "delete" {
		return s.delete(stub, args)
	}

	return shim.Error("Invalid Smart Contract function name.")
}

func (s *SmartContract) create(stub shim.ChaincodeStubInterface, args []string) pb.Response {

	if len(args) != 2 {
		return shim.Error("Incorrect number of arguments. Expecting 2")
	}

	_key  	:= args[0]
	_data	:= args[1]

	if(_data == ""){
		return shim.Error("Incorrect string of data")
	}

	existAsBytes,err := stub.GetState(_key)
	if string(existAsBytes) != "" {
		fmt.Println("Failed to create account, Duplicate key.")
		return shim.Error("Failed to create account, Duplicate key.")
	}

	err = stub.PutState(_key, []byte(_data))
	if err != nil {
		return shim.Error(err.Error())
	}
	fmt.Printf("create %s %s \n", _key, string(_data))

	return shim.Success(nil)
}

func (s *SmartContract) find(stub shim.ChaincodeStubInterface, args []string) pb.Response {

	if len(args) != 1 {
		return shim.Error("Incorrect number of arguments. Expecting 1")
	}

	_key  	:= args[0]
	_data, err := stub.GetState(_key)
	if err != nil {
		return shim.Error(err.Error())
	}
	if string(_data) == "" {
		return shim.Error("The key isn't exist.")
	}else{
		fmt.Printf("query %s %s \n", _key, string(_data))
	}

	return shim.Success(_data)
}

func (s *SmartContract) update(stub shim.ChaincodeStubInterface, args []string) pb.Response {

	if len(args) != 2 {
		return shim.Error("Incorrect number of arguments. Expecting 2")
	}

	_key  	:= args[0]
	_data	:= args[1]

	if(_data == ""){
		return shim.Error("Incorrect string of data")
	}

	err := stub.PutState(_key, []byte(_data))
	if err != nil {
		return shim.Error(err.Error())
	}else{
		fmt.Printf("update %s %s \n", _key, string(_data))
	}
	
	return shim.Success(nil)
}

// Deletes an entity from state
func (t *SmartContract) delete(stub shim.ChaincodeStubInterface, args []string) pb.Response {
	if len(args) != 1 {
		return shim.Error("Incorrect number of arguments. Expecting 1")
	}

	_key := args[0]

	// Delete the key from the state in ledger
	err := stub.DelState(_key)
	if err != nil {
		return shim.Error("Failed to delete state")
	}

	return shim.Success(nil)
}

func main() {

	err := shim.Start(new(SmartContract))
	if err != nil {
		fmt.Printf("Error creating new Smart Contract: %s", err)
	}
}
		
		
		

鏈碼有四個函數，分別是創建，查找，更新，刪除。

		
	if function == "create" {
		return s.create(stub, args)		// 創建
	} else if function == "find" {
		return s.find(stub, args)		// 查找
	} else if function == "update" {
		return s.update(stub, args)		// 更新
	} else if function == "delete" {
		return s.delete(stub, args)		// 刪除
	}		
		
		

上鏈使用 create 方法，函數有兩個參數，一個是 key, 另一個是數據。

key 使用 UUID 存儲再資料庫和鏈上，同時 UUID 對應通證的

data 是序列化 byte 數據。例如可以使用 json, hession, msgpack 等序列化後的數據。

		
err = stub.PutState(_key, []byte(_data))		
		
		

這個鏈碼考慮到前期產品上市，不確定性因素很多，需要更新和刪除等等。後期我們可以在數據中設置一個 status 變數，當 status = false 就不在允許數據的刪除和更新。