Fabric's smart contract is called chain code, which is divided into system chain code and user chain code. System chain code is used to realize system level functions, and user chain code is used to realize user application functions. The chain code is compiled into an independent application that runs in an isolated Docker container.
Fabric Smart Contract
Fabric's smart contract is called chain code, which is divided into system chain code and user chain code. System chain code is used to realize system level functions, and user chain code is used to realize user application functions.
The chain code is compiled into an independent application that runs in an isolated Docker container.
Fabric chain code and the underlying ledger are separated. When upgrading the chain code, it is not necessary to migrate the ledger data to the new chain code, which truly realizes the separation of logic and data. At the same time, the chain code is written in Go, Java, and Nodejs languages.
链码运作流程
智能合约由区块链内的多个用户共同参与制定，可用于用户之间的任何交易行为。协议中明确了双方的权利和义务，开发人员将这些权利和义务以电子化的方式进行编程，代码中包含会触发合约自动执行的条件。
编码完成后，将智能合约就被安装,实例化到区块链网络中。
执行合约,并将结果记录到区块链上。
/**
*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);
}
}
