Patch Swap

import fetch from "node-fetch";
import { ERC20TokenContract, WETH9Contract, ContractWrappers } from '@0x/contract-wrappers';
import { BigNumber } from '@0x/utils';
import axios from 'axios';
import Web3 from 'web3';
import qs from 'qs';
import { ethers } from 'ethers';
import { findTokenBySymbolOrName } from './data_all_tokens.js';
import pkg from '@0x/contract-addresses';
import dotenv from 'dotenv';
dotenv.config();

// import { PatchWallet } from "./PatchWallet.js";

// ** PATCH CLASS **
export class PatchWallet {
    constructor() {
        this.API_BASE_URL = 'https://paymagicapi.com/v1/';
    }

    async auth(clientId, clientSecret) {
        const url = `${this.API_BASE_URL}auth`;
        const response = await axios.post(url, {
            client_id: clientId,
            client_secret: clientSecret,
        });
        return response.data.access_token;
    }

    async accounts(users, token) {
        const url = `${this.API_BASE_URL}resolver`;
        const userIds = users.map(user => `${user.provider}:${user.username}`).join(',');
        const response = await axios.post(url, {
            userIds
        }, {
            headers: {
                'Content-Type': 'text/plain',
                'Authorization': `Bearer ${token}`,
            },
        });
        return response.data;
    }

    async tx(tx, token) {
        const url = `${this.API_BASE_URL}base/tx`;
        try {
            const response = await axios.post(url, {
                ...tx,
                chain: tx.chain,
            }, {
                headers: {
                    'Content-Type': 'text/plain',
                    'Authorization': `Bearer ${token}`,
                },
            });
            return response.data;
        } catch (error) {
            console.log(error);
        }

    }

    async buildTx({ userId, chain, to, value, data}) {
        // if (!accessToken) {
        //   accessToken = await patch.auth(clientId, clientSecret);
        // }

        const txInput = {
            userId,
            chain,
            to: [to],
            value: [value],
            data: [data]
        };
        return txInput


    }
}
const patch = new PatchWallet();
const clientId = process.env.PATCH_CLIENT_ID
const clientSecret = process.env.PATCH_CLIENT_SECRET;



//* SWAP FILE *//
const { ContractAddresses  } = pkg;
//import WETH contract address
// let wethAddress = '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1'
// const uni_token_arbitrum = '0xFa7F8980b0f1E64A2062791cc3b0871572f1F7f0';
// const usdc_token_arbitrum = '0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8';
// const myaddress = "0x5A68C82e4355968DB53177033ad3eDCfD62aCCcA";

// //DEFAULT
// const default_params = {
//   sellToken: usdc_token_arbitrum,
//   buyToken: uni_token_arbitrum,
//   sellAmount: '1000000',
//   takerAddress: myaddress, //users wallet
// };

//note: wei = smallest unit of currency (not just eth)
export function amountToWei(amount, decimals) {
  const wei = new BigNumber(amount).times(new BigNumber(10).pow(decimals));
  return wei;
}

let web3
export function getProvider(chainId) {
    chainId = chainId.toString();

    switch (chainId) {
        case '1':
            const rUrlE = process.env.RPC_URL_MAINNET
            web3 = new Web3(rUrlE);
            return new ethers.providers.JsonRpcProvider(rUrE)
        case '42161':
            const rUrlA = process.env.RPC_URL_ARB_MAIN
            web3 = new Web3(rUrlA);
            return new ethers.providers.JsonRpcProvider(rUrlA)
        case '137':
            const rUrlM = process.env.RPC_URL_MATIC
            web3 = new Web3(rUrlM)
            return new ethers.providers.JsonRpcProvider(rUrlM)
    }
}
export function get0xUrl(chainId) {
    chainId = chainId.toString();
    switch (chainId) {
        case '1':
            return 'https://api.0x.org/'
        case '42161':
            return 'https://arbitrum.api.0x.org/'
        case '137':
            return 'https://polygon.api.0x.org/'
    }
}
// export const swap = async (swapOptions = {}) => {
export const swap = async (inputTokenSymbol, outputTokenSymbol, inputAmount, takerAddress="0x5A68C82e4355968DB53177033ad3eDCfD62aCCcA", chainId=42161) => {
    // const { ethers } = require('ethers')
    let accessToken = await patch.auth(clientId, clientSecret);
    // Set up provider and signer
    const provider = getProvider(chainId); // Replace with your Infura Project ID
    // const signer = new ethers.Wallet(process.env.ACCOUNT_PKEY, provider); // Replace with your private key

    // Set up ContractWrappers instance
    const contractWrappers = new ContractWrappers(provider, { chainId: chainId }); // for Ethereum mainnet, chainId is 1

    //IF ETH MUST WRAP TO WETH & CHANGE INPUTTOKENSYMBOL TO WETH
    // if (inputTokenSymbol.toLowerCase() === 'eth') {
    //     inputTokenSymbol = 'WETH'; // Change to WETH

    //     const wethDetails = findTokenBySymbolOrName('WETH', chainId); // WETH contract details
    //     const wethAddress = wethDetails.contractAddress; // Extracting the address from the details

    //     const WETHContract = new ethers.Contract(wethAddress, contractWrappers.weth9.abi, provider);
    //     const weiAmount = ethers.utils.parseEther(inputAmount);

    //     // Call the built-in 'populateTransaction' method
    //     let transactionData = await WETHContract.populateTransaction.deposit({
    //         value: weiAmount,
    //         gasLimit: ethers.utils.hexlify(10000000), // Gas limit - different gas limit for each network?
    //     });

    //     //need patch to sign


    //     // transactionData = await WETHContract.populateTransaction.deposit({
    //     //     value: weiAmount,
    //     //     gasLimit: ethers.utils.hexlify(10000000), // Gas limit - different gas limit for each network?
    //     // });
    //     // const tx = await WETHContract.deposit({
    //     //     value: weiAmount,
    //     //     gasLimit: ethers.utils.hexlify(10000000), // Gas limit - different gas limit for each network?
    //     // });
    //     const receipt = await tx.wait();
    //     console.log('deposited eth to weth')

    // }
    let convertedOutputTokenSymbolFrom = false
     if (outputTokenSymbol.toLowerCase() === 'eth') {
        outputTokenSymbol = 'weth'
        convertedOutputTokenSymbolFrom = 'eth'
    }

      let inputToken = findTokenBySymbolOrName(inputTokenSymbol, chainId)
      let outputToken = findTokenBySymbolOrName(outputTokenSymbol, chainId)

      let inputAmountWei = amountToWei(inputAmount, inputToken.decimals).toString()


      let params = {}
      params.sellToken = inputToken.contractAddress
      params.buyToken = outputToken.contractAddress
      params.sellAmount = inputAmountWei
      params.takerAddress = takerAddress


//
  if (!params) {
    params = default_params
  }

  // const {
  //   sellToken = params.sellToken || usdc_token_arbitrum,
  //   buyToken = params.buyToken || uni_token_arbitrum,
  //   sellAmount = params.sellAmount || '1000000',
  //   takerAddress = params.takerAddress || myaddress
  // } = params;

  let paramsForQuery = Object.assign({}, params);
  delete  paramsForQuery.takerAddress; // Remove the takerAddress property from the queryParams object

  // const ZERO_EX_ADDRESS = '0xdef1c0ded9bec7f1a1670819833240f027b25eff';
  const swapUrl = `${get0xUrl(chainId)}swap/v1/quote?`
  const queryParams = `${qs.stringify(paramsForQuery)}`
  const headers = { '0x-api-key': 'ef1357cf-4031-4dcb-a985-a1856193cc18' }
  const quoteResponse = await fetch( swapUrl+queryParams, { headers } )//DON"T INCLUDE ADDR FOR QUOTE //PARAMS reference: https://0x.org/docs/0x-swap-api/guides/swap-tokens-with-0x-swap-api
  const quote = await quoteResponse.json();


    const SellTokenContract = new ERC20TokenContract(params.sellToken, web3.eth.currentProvider);

    const currentAllowance = await SellTokenContract.allowance(params.takerAddress, quote.allowanceTarget).callAsync();
    console.log(`Your allowance for the 0x Exchange Proxy is ${currentAllowance} tokens.`);
    // const currentAllowance = new BigNumber(
    //     USDCcontract.allowance(params.takerAddress, ZERO_EX_ADDRESS)
    //     );
    const big_currentAllowance = new BigNumber(currentAllowance);
    const big_sellAmount = new BigNumber(params.sellAmount);

    console.log(big_currentAllowance.isLessThan(big_sellAmount));
    const maxApproval = new BigNumber(2).pow(256).minus(1);

    let approvalTx = false
        if (currentAllowance.isLessThan(params.sellAmount)) {
            console.log("current allowance is less than sellAmount")
            const approvalTxData = SellTokenContract.approve(quote.allowanceTarget, maxApproval).getABIEncodedTransactionData();
            const nonce = await web3.eth.getTransactionCount(takerAddress);

            const txInput = {
                userId:  "lang:imran",
                chain: "matic",
                to: [`${outputToken.contractAddress}`],
                value: ["0"],
                data: [approvalTxData],
            };

            const tx = await patch.tx(txInput, accessToken);
            console.log('approval tx', tx)

        }
        const baseFeePerGas = await provider.getGasPrice();

        const maxPriorityFeePerGas = ethers.utils.parseUnits('0.4', 'gwei');
        const maxFeePerGas = baseFeePerGas.add(maxPriorityFeePerGas);

        const gweiToWei = (gweiValue) => {
            return ethers.utils.parseUnits(gweiValue.toString(), "gwei");
          };

        // let etherBalanceBefore = await provider.getBalance(takerAddress)
        // etherBalanceBefore =  ethers.utils.formatEther(etherBalanceBefore);
        // const nonce = await web3.eth.getTransactionCount(myaddress);

        // here we'd send back:
        let tx_data = quote.data
        let tx_to = quote.to
        let tx_from = quote.from

        const swapInput = {
            userId:  "lang:imran",
            chain: "matic",
            to: [`${quote.to}`], // USDC
            value: [`${quote.value}`],
            data: [`${quote.data}`], // Send 0.01 USDC to my account
        };


        accessToken = await patch.auth(clientId, clientSecret);
        const tx = await patch.tx(swapInput, accessToken);



        try {
          const tx =  await signer.sendTransaction({
            from: quote.from,
            to: quote.to,
            data: quote.data,
            value: ethers.BigNumber.from(quote.value || 0),
            // gasPrice: quote.gas, //?? 1304845598380 // Set an appropriate gas limit for the transaction
            gasLimit: quote.gas,
            // nonce: nonce,
            maxPriorityFeePerGas: ethers.utils.parseUnits('0.001', "gwei"),
            maxFeePerGas: ethers.utils.parseUnits('0.15', "gwei"),

          });
          const swapTx = tx

          return {
            approvalTx: approvalTx,
            swapTx: swapTx,
            etherBalanceBefore: etherBalanceBefore,
            etherBalanceAfter: etherBalanceAfter,
            comment: unwrapComment
          };

        } catch(err) {
          console.log("swap error", err,  err.message)
          return 'swap failed!'

        }

    }

    //this addr is the lang:imran acct
    swap("USDC", "uni", "0.1", '0x4c8c013AC1d7406647d88A7f5620E737A92F726b', 137).then( (result) => {
      console.log(result);
    })