区块链交易所系统开发：探究源码案例分析

技术博客 1周前 Dexnav

0 23

区块链交易所系统开发：探究源码案例分析:量化交易的主要特点在于其利用定量模型来决定买卖，而不是由人们的主观判断。通过建立数学模型来设定交易的触发条件，程序系统会按照严格的数学模型或市场交易条件自动实现买卖的操作。

以下是一段 Solidity 语言编写的智能合约代码。它是一个名为 kongTou 的合约，该合约的主要功能是实现对以太币和 ERC20、ERC721、ERC1155 标准的代币进行转账操作。该合约提供了转账代币的方法，包括 transferEths()、transferTokens() 和 transferTokenOne() 等，用于将以太币或代币从合约地址转移到指定的地址。除此之外，该合约还提供了销毁合约、检查余额等功能。此外，该合约还包括了限定合约操作人的 onlyOwner 修饰符，以及对地址的非零校验的 notAddress 修饰符。此合约中使用了 OpenZeppelin 中的 ERC20、ERC721、ERC1155 标准代币合约，以及 Solidity 的一些关键字，如 modifier 和 constructor 等。

　//SPDX-License-Identifier:MIT;

　　pragma solidity^0.8;

　　import"openzeppelin/contracts/token/ERC721/IERC721.sol";

　　import"openzeppelin/contracts/token/ERC20/IERC20.sol";

　　import"openzeppelin/contracts/token/ERC1155/IERC1155.sol";

　　contract kongTou{
　　address owner;

　　modifier onlyOwner(){

　　require(msg.sender==owner,"only owner can call this");

　　_;

　　}

　　modifier notAddress(address _useAdd){

　　require(_useAdd!=address(0),"address is error");

　　_;

　　}
　　event Received(address,uint);

　　constructor()payable{

　　owner=msg.sender;

　　}

　　receive()external payable{

　　emit Received(msg.sender,msg.value);

　　}

　　function pay()public payable{

　　}

　　function transferEthsAvg(address[]memory _tos)

　　payable

　　public

　　onlyOwner

　　returns(bool){

　　require(_tos.length>0);

　　uint oneValue=address(this).balance/_tos.length;

　　for(uint i=0;i<_tos.length;i++){

　　require(_tos<i>!=address(0));

　　payable(_tos<i>).transfer(oneValue);

　　}

　　return true;

　　}

　　function transferEths(address[]memory _tos,uint256[]memory _values)

　　payable

　　public

　　onlyOwner

　　returns(bool){

　　require(_tos.length>0);

　　require(_tos.length==_values.length);

　　for(uint32 i=0;i<_tos.length;i++){

　　require(_tos<i>!=address(0));

　　require(_values<i>>0);

　　payable(_tos<i>).transfer(_values<i>);

　　}

　　return true;

　　}

　　function transferEth(address _to)

　　payable

　　public

　　onlyOwner

　　returns(bool){

　　require(_to!=address(0));

　　require(msg.value>0);

　　payable(_to).transfer(msg.value);

　　return true;

　　}

　　function checkBalance()

　　public

　　view

　　returns(uint){

　　return address(this).balance;

　　}

　　function destroy()

　　public

　　onlyOwner

　　{

　　selfdestruct(payable(msg.sender));

　　}

　　function transferTokensAvg(address from,address _constractAdd,address[]memory _tos,uint _v)

　　public

　　onlyOwner

　　notAddress(from)

　　notAddress(_constractAdd)

　　returns(bool){

　　require(_tos.length>0);

　　require(_v>0);

　　IERC20 _token=IERC20(_constractAdd);

　　//要调用的方法id进行编码

　　//bytes4 methodId=bytes4(keccak256("transferFrom(address,address,uint256)"));

　　for(uint i=0;i<_tos.length;i++){

　　require(_tos<i>!=address(0));

　　require(_token.transferFrom(from,_tos<i>,_v));

　　//_constractAdd.call(abi.encodeWithSignature("transferFrom(address,address,uint256)",from,_tos<i>,_v));

　　//_constractAdd.call(methodId,from,_tos<i>,_v);

　　}

　　return true;

　　}

　　function transferTokens(address from,address _constractAdd,address[]memory _tos,uint[]memory _values)

　　public

　　onlyOwner

　　notAddress(from)

　　returns(bool){

　　require(_tos.length>0);

　　require(_values.length>0);

　　require(_values.length==_tos.length);

　　bool status;

　　bytes memory msgs;

　　//要调用的方法id进行编码

　　//bytes4 methodId=bytes4(keccak256("transferFrom(address,address,uint256)"));

　　for(uint i=0;i<_tos.length;i++){

　　require(_tos<i>!=address(0));

　　require(_values<i>>0);

　　(status,msgs)=_constractAdd.call(abi.encodeWithSignature("transferFrom(address,address,uint256)",from,_tos<i>,_values<i>));

　　require(status==true);

　　//require(_constractAdd.call(methodId,from,_tos<i>,_values<i>));

　　}

　　return true;

　　}

　　function transferTokenOne(address _from,address _constractAdd,address _to,uint _tokenId)

　　public

　　notAddress(_from)

　　notAddress(_constractAdd)

　　notAddress(_to)

　　onlyOwner

　　returns(bool){

　　IERC721 _token=IERC721(_constractAdd);

　　_token.safeTransferFrom(_from,_to,_tokenId);

　　return true;

　　}

　　function transferToken1155(address _from,address _contractAdd,address _to,uint _tokenId,uint _num)

　　public

　　notAddress(_from)

　　notAddress(_contractAdd)

　　notAddress(_to)

　　returns(bool){

　　IERC1155 _token=IERC1155(_contractAdd);

　　_token.safeTransferFrom(_from,_to,_tokenId,_num,"");

　　return true;

　　}

　　function transferTokenBatch1155(address _from,address _contractAdd,address _to,uint[]memory _tokenIds,uint[]memory _nums)

　　public

　　notAddress(_from)

　　notAddress(_contractAdd)

　　notAddress(_to)

　　returns(bool){

　　IERC1155 _token=IERC1155(_contractAdd);

　　_token.safeBatchTransferFrom(_from,_to,_tokenIds,_nums,"");

　　return true;

　　}

　　}