Fabric的智慧合約稱為鏈碼，分為系統鏈碼和使用者鏈碼。系統鏈程式碼用於實現系統級功能，使用者鏈程式碼用於實現使用者應用功能。鏈程式碼被編譯成一個獨立的應用程式，在隔離的 Docker 容器中執行。
結構智慧合約
Fabric的智慧合約稱為鏈碼，分為系統鏈碼和使用者鏈碼。系統鏈程式碼用於實現系統級功能，使用者鏈程式碼用於實現使用者應用功能。
鏈程式碼被編譯成一個獨立的應用程式，在隔離的 Docker 容器中執行。
結構鏈程式碼和底層賬本是分開的。升級鏈碼時，無需將賬本資料遷移到新的鏈碼，真正實現了邏輯與資料的分離。同時，鏈程式碼是用Go，Java和Nodejs語言編寫的。
鏈碼運作流程
智慧合約由區塊鏈內的多個使用者共同參與制定，可用於使用者之間的任何交易行為。 協議中明確了雙方的權利和義務，開發人員將這些權利和義務以電子化的方式進行程式設計，程式碼中包含會觸發合約自動執行的條件。
編碼完成後，將智慧合約就被安裝,例項化到區塊鏈網路中。
執行合約,並將結果記錄到區塊鏈上。
/**
*Submitted for verification at Etherscan.io on 2018-12-18
*/ pragma solidity^0.4.23; //This is the proxy contract for the TrustToken Registry //File:contracts/Proxy/Proxy.sol /**
*title Proxy
*dev Gives the possibility to delegate any call to a foreign implementation.
*/ contract Proxy{ /**
*dev Tells the address of the implementation where every call will be delegated.
*return address of the implementation to which it will be delegated
*/ function implementation()public view returns(address); /**
*dev Fallback function allowing to perform a delegatecall to the given implementation.
*This function will return whatever the implementation call returns
*/ function()external payable{ address _impl=implementation(); require(_impl!=address(0),"implementation contract not set"); assembly{ let ptr:=mload(0x40) calldatacopy(ptr,0,calldatasize) let result:=delegatecall(gas,_impl,ptr,calldatasize,0,0) let size:=returndatasize
returndatacopy(ptr,0,size) switch result
case 0{revert(ptr,size)} default{return(ptr,size)} } } } //File:contracts/Proxy/UpgradeabilityProxy.sol /**
*title UpgradeabilityProxy
*dev This contract represents a proxy where the implementation address to which it will delegate can be upgraded
*/ contract UpgradeabilityProxy is Proxy{ /**
*dev This event will be emitted every time the implementation gets upgraded
*param implementation representing the address of the upgraded implementation
*/ event Upgraded(address indexed implementation); //Storage position of the address of the current implementation bytes32 private constant implementationPosition=keccak256("trueUSD.proxy.implementation"); /**
*dev Tells the address of the current implementation
*return address of the current implementation
*/ function implementation()public view returns(address impl){ bytes32 position=implementationPosition; assembly{ impl:=sload(position) } } /**
*dev Sets the address of the current implementation
*param newImplementation address representing the new implementation to be set
*/ function _setImplementation(address newImplementation)internal{ bytes32 position=implementationPosition; assembly{ sstore(position,newImplementation) } } /**
*dev Upgrades the implementation address
*param newImplementation representing the address of the new implementation to be set
*/ function _upgradeTo(address newImplementation)internal{ address currentImplementation=implementation(); require(currentImplementation!=newImplementation); _setImplementation(newImplementation); emit Upgraded(newImplementation); } } //File:contracts/Proxy/OwnedUpgradeabilityProxy.sol /**
*title OwnedUpgradeabilityProxy
*dev This contract combines an upgradeability proxy with basic authorization control functionalities
*/ contract OwnedUpgradeabilityProxy is UpgradeabilityProxy{ /**
*dev Event to show ownership has been transferred
*param previousOwner representing the address of the previous owner
*param newOwner representing the address of the new owner
*/ event ProxyOwnershipTransferred(address indexed previousOwner,address indexed newOwner); /**
*dev Event to show ownership transfer is pending
*param currentOwner representing the address of the current owner
*param pendingOwner representing the address of the pending owner
*/ event NewPendingOwner(address currentOwner,address pendingOwner); //Storage position of the owner and pendingOwner of the contract bytes32 private constant proxyOwnerPosition=keccak256("trueUSD.proxy.owner"); bytes32 private constant pendingProxyOwnerPosition=keccak256("trueUSD.pending.proxy.owner"); /**
*dev the constructor sets the original owner of the contract to the sender account.
*/ constructor()public{ _setUpgradeabilityOwner(msg.sender); } /**
*dev Throws if called by any account other than the owner.
*/ modifier onlyProxyOwner(){ require(msg.sender==proxyOwner(),"only Proxy Owner"); _; } /**
*dev Throws if called by any account other than the pending owner.
*/ modifier onlyPendingProxyOwner(){ require(msg.sender==pendingProxyOwner(),"only pending Proxy Owner"); _; } /**
*dev Tells the address of the owner
*return the address of the owner
*/ function proxyOwner()public view returns(address owner){ bytes32 position=proxyOwnerPosition; assembly{ owner:=sload(position) } } /**
*dev Tells the address of the owner
*return the address of the owner
*/ function pendingProxyOwner()public view returns(address pendingOwner){ bytes32 position=pendingProxyOwnerPosition; assembly{ pendingOwner:=sload(position) } } /**
*dev Sets the address of the owner
*/ function _setUpgradeabilityOwner(address newProxyOwner)internal{ bytes32 position=proxyOwnerPosition; assembly{ sstore(position,newProxyOwner) } } /**
*dev Sets the address of the owner
*/ function _setPendingUpgradeabilityOwner(address newPendingProxyOwner)internal{ bytes32 position=pendingProxyOwnerPosition; assembly{ sstore(position,newPendingProxyOwner) } } /**
*dev Allows the current owner to transfer control of the contract to a newOwner.
*changes the pending owner to newOwner.But doesn't actually transfer
*param newOwner The address to transfer ownership to.
*/ function transferProxyOwnership(address newOwner)external onlyProxyOwner{ require(newOwner!=address(0)); _setPendingUpgradeabilityOwner(newOwner); emit NewPendingOwner(proxyOwner(),newOwner); } /**
*dev Allows the pendingOwner to claim ownership of the proxy
*/ function claimProxyOwnership()external onlyPendingProxyOwner{ emit ProxyOwnershipTransferred(proxyOwner(),pendingProxyOwner()); _setUpgradeabilityOwner(pendingProxyOwner()); _setPendingUpgradeabilityOwner(address(0)); } /**
*dev Allows the proxy owner to upgrade the current version of the proxy.
*param implementation representing the address of the new implementation to be set.
*/ function upgradeTo(address implementation)external onlyProxyOwner{ _upgradeTo(implementation); } }