wagmi: React Hooks for Ethereum

    func checkInternetConnection() {
        
        let internetConnected = Reachability.isConnectedToNetwork()
        
        if !internetConnected {
            print("no internet")
            self.showToast(message: "no internet")
        }
    }

//
//  Reachability.swift
//  Vital
//
//  Created by Mac HD on 30/01/2023.
//

import SystemConfiguration

public class Reachability {

    class func isConnectedToNetwork() -> Bool {

        var zeroAddress = sockaddr_in(sin_len: 0, sin_family: 0, sin_port: 0, sin_addr: in_addr(s_addr: 0), sin_zero: (0, 0, 0, 0, 0, 0, 0, 0))
        zeroAddress.sin_len = UInt8(MemoryLayout.size(ofValue: zeroAddress))
        zeroAddress.sin_family = sa_family_t(AF_INET)

        let defaultRouteReachability = withUnsafePointer(to: &zeroAddress) {
            $0.withMemoryRebound(to: sockaddr.self, capacity: 1) {zeroSockAddress in
                SCNetworkReachabilityCreateWithAddress(nil, zeroSockAddress)
            }
        }

        var flags: SCNetworkReachabilityFlags = SCNetworkReachabilityFlags(rawValue: 0)
        if SCNetworkReachabilityGetFlags(defaultRouteReachability!, &flags) == false {
            return false
        }

        /* Only Working for WIFI
        let isReachable = flags == .reachable
        let needsConnection = flags == .connectionRequired

        return isReachable && !needsConnection
        */

        // Working for Cellular and WIFI
        let isReachable = (flags.rawValue & UInt32(kSCNetworkFlagsReachable)) != 0
        let needsConnection = (flags.rawValue & UInt32(kSCNetworkFlagsConnectionRequired)) != 0
        let ret = (isReachable && !needsConnection)

        return ret

    }
}

import "./ICreditLineFactory.sol";

contract CreditDesk {
  address public creditLineFactoryAddress;

  function createCreditLine(CreditLineParams params) public {
    require(validParams(params), "invalid params!");
    
    ICreditLineFactory(creditLineFactoryAddress).createCreditLine(params);
  }
}

pragma solidity ^0.5.11;

contract A {
    address addressB;
    function setAddressB(address _addressB) external {
        addressB = _addressB;
    }
    function callHelloWorld() external view returns(string memory) {
        B b = B(addressB);
        return b.helloWorld();
    }
}

contract B {
    function helloWorld() external pure returns(string memory) {
        return 'HelloWorld';
    }
}



contract MyContract {
    uint a;
    function foo() external {
        if(a == 10) {
            revert('error');
        }
        require(a != 10, 'err');
        assert(a != 10);
    }
    function willThrow() external {
        require(true == false, 'the reasons');
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.7;

contract HelloWeb3 {
    string public getName;

    constructor() {
      getName = "Unknown";
    }

    function setName(string memory newName) public{
		  getName = newName;
    }
}

contract Transaction {
    event EnteredTransfer(
        uint256 indexed date,
        address from,
        address indexed to,
        uint256 value
    );
}

   function enterTransfer(address to) public payable {
     
    emit EnteredTransfer(block.timestamp, msg.sender, to, msg.value);
    
   }