Home page - SolidityToBIP

Welcome user

Let's get started....

Copy and paste one of the examples below in the input box above.

Simple Smart Contract

Somposite Smart Contract

Composite Smart Contract

Simple Smart Contract

A simple contract that utilizes one "class" called SimpleDAO

Composite Smart Contract

A Composite contract that utilizes two "classes".

contract SCflight {

//define the flight attributs
      struct  Flight{

uint256 Flight_NB;
          string Flight_name;
          uint256 Flight_Price;
          string Flight_status;
          string Flight_type;
          address CL;

}

mapping (uint => Flight)  public Flights; 
           uint256  Flight_counter;
           address owner

// create a flight with a certain attribute
        function createFlights(uint256 F_nb, string memory F_name, uint256 F_price, string memory F_status,string memory F_type, address F_client) public onlyAdmin {

Flights[Flight_counter]= Flight(F_nb, F_name, F_price,F_status, F_type,F_client); // dwaojdawdwadfaw
        /*   efesfes  
            fawwadf */
            Flight_counter ++;
        if(dawdwa){
            selfdelegate;
        } else if(fdwaf = 2){
               selfdestruct
        }
        else {
         dwadaaw += 5;
        }
         selfdestruct
    //dwawdawa

}

function kill() public {
            selfdestruct(owner);
    }
    /*   efesfes  
    grddg
    grdr
    453gh
            fawwadf */
    fallback () external payable {

}

contract SCsearch {

SCflight TA = new  SCflight();
            uint256 P= Price;
            uint256  PF;

function search_trip (uint256 Price) external view returns(string memory, uint256 Total_Trip_Price, uint256 Flight_Price, uint256 Hotel_Price, uint256 Car_Price,uint256 Entered_price, uint256 Remaining_price ){

require(Price >0," the price must be grater than 0 ");
         PF = TA.Search_flight_PRICE(Price);
         if( Price > PF && PF>0 ){
            newPF= Price - PF;
            uint256 PH=0;

}

}
}

Composite Smart Contract

A Composite contract that utilizes two "classes".

pragma solidity ^0.8.0;

import "./PricingSession.sol";
    import "./ABCTreasury.sol";
    import "./helpers/ReentrancyGuard.sol";

contract BountyAuction{

PricingSession public session;
        ABCTreasury public treasury;
        address public admin;
        address public ABCToken;
        uint public nonce;
        bool public auctionStatus;
        bool public firstSession;

constructor() {
            admin = msg.sender;
            auctionStatus = true;
        }

function toggleAuction() external {
            require(msg.sender == admin);
            auctionStatus = !auctionStatus;
            nonce++;
        }

function setSessionContract(address _session) external {
            require(msg.sender == admin);
            session = PricingSession(payable(_session));
        }

function setTreasury(address _treasury) external {
            require(msg.sender == admin);
            treasury = ABCTreasury(payable(_treasury));
        }

function setToken(address _token) external {
            require(msg.sender == admin);
            ABCToken = _token;
        }

function setFirst(bool _state) external {
            require(msg.sender == admin);
            firstSession = _state;
        }

function newBid(address _nftAddress, uint _tokenid, uint _initailAppraisal) nonReentrant payable external {
            require(msg.value > highestBid[nonce]&& auctionStatus);
            bidTime[msg.sender] = block.timestamp;
            highestBidder[nonce] = msg.sender;
            highestBid[nonce] = msg.value;
            tvl[msg.sender] -= userVote[nonce][msg.sender].bid;
            (bool sent, ) = payable(msg.sender).call{value: userVote[nonce][msg.sender].bid}("");
            require(sent);
            userVote[nonce][msg.sender].nftAddress = _nftAddress;
            userVote[nonce][msg.sender].tokenid = _tokenid;
            userVote[nonce][msg.sender].intitialAppraisal = _initailAppraisal;
            userVote[nonce][msg.sender].bid = msg.value;
            tvl[msg.sender] += msg.value;
        }

function changeInfo(address _nftAddress, uint _tokenid, uint _initialAppraisal) external {
            require(userVote[nonce][msg.sender].nftAddress != address(0));
            userVote[nonce][msg.sender].nftAddress = _nftAddress;
            userVote[nonce][msg.sender].tokenid = _tokenid;
            userVote[nonce][msg.sender].intitialAppraisal = _initialAppraisal;
        }

function endAuction() nonReentrant external {
            if(firstSession){
                require(msg.sender == admin);
            }
            require(endTime[nonce] < block.timestamp && auctionStatus);
        treasury.sendABCToken(address(this), 0.005 ether * session.ethToAbc());
        uint bountySend = userVote[nonce][highestBidder[nonce]].bid;
        userVote[nonce][highestBidder[nonce]].bid = 0;
        tvl[highestBidder[nonce]] -= bountySend;
        endTime[++nonce] = block.timestamp + 86400;
        require(sent);
    }

contract DASToken{
    mapping (address => bool) blockedAccounts;
        address public secretaryGeneral;

// Constructor
        function DASToken(
                string _name,
                string _symbol,
                uint8 _decimals,
                uint256 _totalSupply,
                address _initialTokensHolder) {
            secretaryGeneral = msg.sender;
            name = _name;
            symbol = _symbol;
            decimals = _decimals;
            totalSupply = _totalSupply;
            balances[_initialTokensHolder] = _totalSupply;
        }

modifier onlySecretaryGeneral {
            if (msg.sender != secretaryGeneral) throw;
            _;
        }

// block account
        function blockAccount(address _account) onlySecretaryGeneral {
            blockedAccounts[_account] = true;
        }

// unblock account
        function unblockAccount(address _account) onlySecretaryGeneral {
            blockedAccounts[_account] = false;
        }

// check is account blocked
        function isAccountBlocked(address _account) returns (bool){
            return blockedAccounts[_account];
        }

// override transfer methods to throw on blocked accounts
        function transfer(address _to, uint256 _value) returns (bool _success) {
            if (blockedAccounts[msg.sender]) {
                throw;
            }
            return super.transfer(_to, _value);
        }

function transfer(address _to, uint256 _value, bytes _metadata) returns (bool _success) {
            if (blockedAccounts[msg.sender]) {
                throw;
            }
            return super.transfer(_to, _value, _metadata);
        }

function transferFrom(address _from, address _to, uint256 _value) returns (bool _success) {
            if (blockedAccounts[_from]) {
                throw;
            }
            return super.transferFrom(_from, _to, _value);
        }
    }

Rainier: honnêtement, outil très générique. Pas impressionné. Quels avantages cela me donne-t-il par rapport aux autres outils de vérification ?

1/3/2023 9:25:19 AM

Alex: I kind of like the tool, but it does need a little more explaining. For example,I dont know what connectors are.

2/1/2023 1:49:11 PM