执行合约,并将结果记录到区块链上。
　　/**
　　*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);　　}　　}