Created using remix-ide: Realtime Ethereum Contract Compiler and Runtime. Load this file by pasting this gists URL or ID at https://remix.ethereum.org/#version=soljson-v0.8.22+commit.4fc1097e.js&optimize=false&runs=200&gist=

.prettierrc.json

{
    "overrides": [
        {
            "files": "*.sol",
            "options": {
                "printWidth": 80,
                "tabWidth": 4,
                "useTabs": false,
                "singleQuote": false,
                "bracketSpacing": false
            }
        },
        {
            "files": "*.yml",
            "options": {}
        },
        {
            "files": "*.yaml",
            "options": {}
        },
        {
            "files": "*.toml",
            "options": {}
        },
        {
            "files": "*.json",
            "options": {}
        },
        {
            "files": "*.js",
            "options": {}
        },
        {
            "files": "*.ts",
            "options": {}
        }
    ]
}

contracts...Flashloan.sol

pragma solidity ^0.8.0;

contract loan {

    string public  name="lp_Loan";
    string public  symbol="LL";
    uint256 public totalSupply;
    mapping(address => uint256) public _balance;

    event Transfer(address indexed from, address indexed to, uint256 value);

    constructor() {
    }

    function balanceOf(address owner) public view returns (uint256) {
        return _balance[owner];
    }

    function _mint(uint256 amount) internal {
        _balance[msg.sender] = _balance[msg.sender] + amount;
        totalSupply+=amount;
        emit Transfer(address(0), msg.sender, amount);
    }

    function _burn(uint256 amount) internal {
        _balance[msg.sender] = _balance[msg.sender] - amount;
        totalSupply = totalSupply - amount;
        emit Transfer(msg.sender, address(0), amount);
}
//Deposit ETH to receive tokens
    function deposit() public payable returns(uint256){
        uint256 value=address(this).balance - msg.value;
        uint256 mint_amount;
        if(totalSupply==0){
            mint_amount=msg.value;
        }
        else{
            mint_amount=msg.value*totalSupply/value;
        }
        _mint(mint_amount);
        return mint_amount;
    }
//Withdraw ETH and burn tokens
    function withdrew(uint256 amount) public returns(uint256){
        uint256 value=address(this).balance;
        uint256 send_amount;
        send_amount = amount * value / totalSupply;
        _burn(amount);
        payable(msg.sender).call{value:send_amount}("");
        return send_amount;
}
//flashloan
    function flash_loan(uint256 amountOut, address to, bytes calldata data) external {
        uint256 value=address(this).balance;
        require(amountOut <= value);
        //Send a loan and call the target contract
        payable(to).call{value:amountOut}(data);
        value=value/100+value;
        //Repayment check, charge a 1% fee
        require(address(this).balance>=value);
    }

    receive() external payable { }
}

scripts...deploy_with_ethers.ts

// This script can be used to deploy the "Storage" contract using ethers.js library.
// Please make sure to compile "./contracts/1_Storage.sol" file before running this script.
// And use Right click -> "Run" from context menu of the file to run the script. Shortcut: Ctrl+Shift+S

import { deploy } from './ethers-lib'

(async () => {
  try {
    const result = await deploy('HelloWorld', [])
    console.log(`address: ${result.address}`)
  } catch (e) {
    console.log(e.message)
  }
})()

scripts...deploy_with_web3.ts

// This script can be used to deploy the "Storage" contract using Web3 library.
// Please make sure to compile "./contracts/1_Storage.sol" file before running this script.
// And use Right click -> "Run" from context menu of the file to run the script. Shortcut: Ctrl+Shift+S

import { deploy } from './web3-lib'

(async () => {
  try {
    const result = await deploy('HelloWorld', [])
    console.log(`address: ${result.address}`)
  } catch (e) {
    console.log(e.message)
  }
})()

scripts...ethers-lib.ts

import { ethers } from 'ethers'

/**
 * Deploy the given contract
 * @param {string} contractName name of the contract to deploy
 * @param {Array<any>} args list of constructor' parameters
 * @param {Number} accountIndex account index from the exposed account
 * @return {Contract} deployed contract
 */
export const deploy = async (contractName: string, args: Array<any>, accountIndex?: number): Promise<ethers.Contract> => {    

  console.log(`deploying ${contractName}`)
  // Note that the script needs the ABI which is generated from the compilation artifact.
  // Make sure contract is compiled and artifacts are generated
  const artifactsPath = `browser/contracts/artifacts/${contractName}.json` // Change this for different path

  const metadata = JSON.parse(await remix.call('fileManager', 'getFile', artifactsPath))
  // 'web3Provider' is a remix global variable object
    
  const signer = (new ethers.providers.Web3Provider(web3Provider)).getSigner(accountIndex)

  const factory = new ethers.ContractFactory(metadata.abi, metadata.data.bytecode.object, signer)

  const contract = await factory.deploy(...args)   

  // The contract is NOT deployed yet; we must wait until it is mined
  await contract.deployed()
  return contract
}

scripts...web3-lib.ts

import Web3 from 'web3'
import { Contract, ContractSendMethod, Options } from 'web3-eth-contract'

/**
 * Deploy the given contract
 * @param {string} contractName name of the contract to deploy
 * @param {Array<any>} args list of constructor' parameters
 * @param {string} from account used to send the transaction
 * @param {number} gas gas limit
 * @return {Options} deployed contract
 */
export const deploy = async (contractName: string, args: Array<any>, from?: string, gas?: number): Promise<Options> => {

  const web3 = new Web3(web3Provider)
  console.log(`deploying ${contractName}`)
  // Note that the script needs the ABI which is generated from the compilation artifact.
  // Make sure contract is compiled and artifacts are generated
  const artifactsPath = `browser/contracts/artifacts/${contractName}.json`

  const metadata = JSON.parse(await remix.call('fileManager', 'getFile', artifactsPath))

  const accounts = await web3.eth.getAccounts()

  const contract: Contract  = new web3.eth.Contract(metadata.abi)

  const contractSend: ContractSendMethod = contract.deploy({
    data: metadata.data.bytecode.object,
    arguments: args
  })

  const newContractInstance = await contractSend.send({
    from: from || accounts[0],
    gas: gas || 1500000
  })
  return newContractInstance.options    
}