joshstevens19 / ethereum-multicall Goto Github PK

const ethereumMulticall = require("ethereum-multicall");
const { ethers } = require("ethers");

//   let provider = ethers.getDefaultProvider();

async function go() {
  // you can use any ethers provider context here this example is
  // just shows passing in a default provider, ethers hold providers in
  // other context like wallet, signer etc all can be passed in as well.
  const multicall = new ethereumMulticall.Multicall({
    nodeUrl: "https://bsc-pokt.nodies.app",
    tryAggregate: true,
  });

  const contractCallContext = [
    {
      reference: "testContract2",
      contractAddress: "0x55d398326f99059fF775485246999027B3197955",
      abi: [
        {
          name: "totalSupply",
          type: "function",
          inputs: [],
          outputs: [{ name: "", type: "uint256" }],
        },
      ],
      calls: [
        {
          reference: "fooTwoCall",
          methodName: "totalSupply",
          methodParameters: [],
        },
      ],
    },
  ];

  const results = await multicall.call(contractCallContext);
  console.log(results);
}

go();

/Users/js/node_modules/@ethersproject/logger/lib/index.js:238
        var error = new Error(message);
                    ^

Error: unable to determine stateMutability (argument="value", value={"name":"totalSupply","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256"}]}, code=INVALID_ARGUMENT, version=abi/5.7.0)
    at Logger.makeError (/Users/js/node_modules/@ethersproject/logger/lib/index.js:238:21)
    at Logger.throwError (/Users/ll/code/js/node_modules/@ethersproject/logger/lib/index.js:247:20)
    at Logger.throwArgumentError (/Users/ll/code/js/node_modules/@ethersproject/logger/lib/index.js:250:21)
    at verifyState (/Users/ll/code/js/node_modules/@ethersproject/abi/lib/fragments.js:588:16)
    at FunctionFragment.fromObject (/Users/ll/code/js/node_modules/@ethersproject/abi/lib/fragments.js:728:21)
    at Fragment.fromObject (/Users/ll/code/js/node_modules/@ethersproject/abi/lib/fragments.js:371:41)
    at Fragment.from (/Users/ll/code/js/node_modules/@ethersproject/abi/lib/fragments.js:363:25)
    at /Users/ll/code/js/node_modules/@ethersproject/abi/lib/interface.js:101:41
    at Array.map (<anonymous>)
    at new Interface (/Users/ll/code/js/node_modules/@ethersproject/abi/lib/interface.js:100:65) {
  reason: 'unable to determine stateMutability',
  code: 'INVALID_ARGUMENT',
  argument: 'value',
  value: {
    name: 'totalSupply',
    type: 'function',
    inputs: [],
    outputs: [ { name: '', type: 'uint256' } ]
  }
}

Node.js v18.17.1

[
    {
      reference: 'factory',
      contractAddress: factoryAddress,
      abi: factoryABI,
      calls: [
        { reference: 'tokenPair', methodName: 'getPair', methodParameters: [tokenAddress, bnbAddress] },
      ]
    },
    {
      reference: 'liquidity',
      contractAddress: tokenPair,   <-----------------------------------------------------------
      abi: [
        {
          'constant': true,
          'inputs': [],
          'name': 'getReserves',
          'outputs': [
            { 'internalType': 'uint112', 'name': '_reserve0', 'type': 'uint112' },
            { 'internalType': 'uint112', 'name': '_reserve1', 'type': 'uint112' },
            { 'internalType': 'uint32', 'name': '_blockTimestampLast', 'type': 'uint32' }
          ],
          'payable': false,
          'stateMutability': 'view',
          'type': 'function'
        }
      ],
      calls: [
        { methodName: 'getReserves' },
      ]
    }
  ]

const multicall = new ethereumMulticall.Multicall({ 
            ethersProvider:hre.ethers.provider, 
            tryAggregate: true, 
            multicallCustomContractAddress: _multiCall3.address  //the address of the deployed multicall
});

[
   {
      "reference":"ERC20PermitToken",
      "contractAddress":"0x871663104598d79D41d89461CC4F18f71b01db3b",
      "abi":[
         {
            "inputs":[
               {
                  "internalType":"address",
                  "name":"owner",
                  "type":"address"
               },
               {
                  "internalType":"address",
                  "name":"spender",
                  "type":"address"
               },
               {
                  "internalType":"uint256",
                  "name":"value",
                  "type":"uint256"
               },
               {
                  "internalType":"uint256",
                  "name":"deadline",
                  "type":"uint256"
               },
               {
                  "internalType":"uint8",
                  "name":"v",
                  "type":"uint8"
               },
               {
                  "internalType":"bytes32",
                  "name":"r",
                  "type":"bytes32"
               },
               {
                  "internalType":"bytes32",
                  "name":"s",
                  "type":"bytes32"
               }
            ],
            "name":"permit",
            "outputs":[
               
            ],
            "stateMutability":"nonpayable",
            "type":"function"
         }
      ],
      "calls":[
         {
            "reference":"permit",
            "methodName":"permit",
            "methodParameters":[
               "0x0C7ebAC9957C01F0b891B912895A811338aF4Ae0",
               "0x02af0F2eE01523357B11cBb1B86BA66eb8D2bfED",
               {
                  "type":"BigNumber",
                  "hex":"0x01"
               },
               {
                  "type":"BigNumber",
                  "hex":"0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
               },
               28,
               "0xef92a36fc7c2fa26ee4275d73918f03ae651708377026c4e936c76f39f9327ca",
               "0x0b2d9ef10de8200043ffccd2be22e68ef94efe96a1411dbff3aa57b913957da0"
            ]
         }
      ]
   }
]

{
   "results":{
      "ERC20PermitToken":{
         "originalContractCallContext":{
            "reference":"ERC20PermitToken",
            "contractAddress":"0x871663104598d79D41d89461CC4F18f71b01db3b",
            "abi":[
               {
                  "inputs":[
                     {
                        "internalType":"address",
                        "name":"owner",
                        "type":"address"
                     },
                     {
                        "internalType":"address",
                        "name":"spender",
                        "type":"address"
                     },
                     {
                        "internalType":"uint256",
                        "name":"value",
                        "type":"uint256"
                     },
                     {
                        "internalType":"uint256",
                        "name":"deadline",
                        "type":"uint256"
                     },
                     {
                        "internalType":"uint8",
                        "name":"v",
                        "type":"uint8"
                     },
                     {
                        "internalType":"bytes32",
                        "name":"r",
                        "type":"bytes32"
                     },
                     {
                        "internalType":"bytes32",
                        "name":"s",
                        "type":"bytes32"
                     }
                  ],
                  "name":"permit",
                  "outputs":[
                     
                  ],
                  "stateMutability":"nonpayable",
                  "type":"function"
               }
            ],
            "calls":[
               {
                  "reference":"permit",
                  "methodName":"permit",
                  "methodParameters":[
                     "0x0C7ebAC9957C01F0b891B912895A811338aF4Ae0",
                     "0x02af0F2eE01523357B11cBb1B86BA66eb8D2bfED",
                     {
                        "type":"BigNumber",
                        "hex":"0x01"
                     },
                     {
                        "type":"BigNumber",
                        "hex":"0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
                     },
                     28,
                     "0xef92a36fc7c2fa26ee4275d73918f03ae651708377026c4e936c76f39f9327ca",
                     "0x0b2d9ef10de8200043ffccd2be22e68ef94efe96a1411dbff3aa57b913957da0"
                  ]
               }
            ]
         },
         "callsReturnContext":[
            {
               "returnValues":"0x",
               "decoded":false,
               "reference":"permit",
               "methodName":"permit",
               "methodParameters":[
                  "0x0C7ebAC9957C01F0b891B912895A811338aF4Ae0",
                  "0x02af0F2eE01523357B11cBb1B86BA66eb8D2bfED",
                  {
                     "type":"BigNumber",
                     "hex":"0x01"
                  },
                  {
                     "type":"BigNumber",
                     "hex":"0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
                  },
                  28,
                  "0xef92a36fc7c2fa26ee4275d73918f03ae651708377026c4e936c76f39f9327ca",
                  "0x0b2d9ef10de8200043ffccd2be22e68ef94efe96a1411dbff3aa57b913957da0"
               ],
               "success":true
            }
         ]
      }
   },
   "blockNumber":8374483
}

{
  hash: '0xb6ea7d514f8b7964a1e0a1a8c37b10cae160c32ad6e8a16689d4acda766a2ace',
  parentHash: '0x642723ef33389137adf06538431ec150f7bec04bb82e23723a78190532457477',
  number: 8374483,
  timestamp: 1674659052,
  nonce: '0x0000000000000000',
  difficulty: 0,
  gasLimit: BigNumber { value: "30000000" },
  gasUsed: BigNumber { value: "3196874" },
  miner: '0xf36F155486299eCAff2D4F5160ed5114C1f66000',
  extraData: '0x',
  transactions: [
    '0xf21146d6ee3ba5588f9d9b1ea40064dfd64897a6b496de0eeb49d9916d3add4f',
    '0xa14b09654b83657d54aaa2501ded1fdb869e08889cccf415f22daf26a55de6e5',
    '0x86e64c989291efd4fde735d1ef416abb195808696744357d13289c2fe789a41b',
    '0xc98927934e5e40787f9d715288ff246d04f1279415bc188880e39a9433f5b0f0',
    '0x96d34d26b0638e15d7cf124db4e752ac3f8a17340558aadcf3f8a73adcfd26d6',
    '0x27b2b5a598a27d3a5777b79fedb8181912fc72ad247deffacd603acbeeb965a7',
    '0xfb8a868734effabec77cadc3a2ae5f843312863493b5f72491fc13a420fb2ff9',
    '0x722452c2fa698cf1296eb43a7f5ee345985ba7be88f14f22cf085a0f2089a610',
    '0x2c4d81baeb0a042ad408b5efcd990add45442a9eb6ba49b34efb99275e5f989e',
    '0x023edeecba8bb5671f27920aea063eb54935c2bfa028b2be716866d43631c952'
  ],
  baseFeePerGas: BigNumber { value: "132" },
  _difficulty: BigNumber { value: "0" }
}

var contract = new web3.eth.Contract(routerAbi, routerAddress);
var swapETHforTokens = contract.methods.swapExactETHForTokens(0, [WBNB, tokenAddress], WalletAddress, timeStamp);
var encodedABI = swapETHforTokens.encodeABI();
var swapETHforTokensTX = {
   from: WalletAddress,
   to: routerAddress,
   gas: 176024,
   data: encodedABI,
   value: web3.utils.toWei(ETHtoSell, 'ether'),
};

await web3.eth
   .call(swapETHforTokenstx, 'pending')
   .then((result) => {
      console.log(web3.eth.abi.decodeLog([{ 'internalType': 'uint256[]', 'name': 'amounts', 'type': 'uint256[]' }], result).amounts[1]);
   })
   .catch((revertReason) => console.log(revertReason));

import {ContractCallContext, Multicall,} from 'ethereum-multicall';
import {ethers} from 'ethers';
import ERC20_ABI from './abi.json' assert {type: 'json'}

let provider = ethers.getDefaultProvider("https://polygon-rpc.com/");

try {
    const walletAddress = "0xe7804c37c13166fF0b37F5aE0BB07A3aEbb6e245"
    const tokenAddresses = ["0x0000000000000000000000000000000000000000"]
    const network = await provider.getNetwork()
    // you can use any ethers provider context here this example is
    // just shows passing in a default provider, ethers hold providers in
    // other context like wallet, signer etc all can be passed in as well.
    const multicall = new Multicall({ ethersProvider: provider, tryAggregate: true });

    const contractCallContext: ContractCallContext[] = tokenAddresses.map((it) => ({
        reference: `${it}`,
        contractAddress: it,
        abi: ERC20_ABI,
        calls: [{ reference: `callBalanceOf:${it}`, methodName: 'balanceOf', methodParameters: [walletAddress] }],
    }))
    const callResults = await multicall.call(contractCallContext)
    const tokenBalancesMap = {} as Record<string, bigint>
    for (const address in callResults.results) {
        try {
            tokenBalancesMap[address] = BigInt(callResults.results[address].callsReturnContext[0].returnValues[0].hex)
        } catch (e) {
            console.warn(`parsing token balance from multicall failed for token ${address} in chain ${network.chainId}`)
        }
    }
    console.log(tokenBalancesMap)
}catch (e) {
    console.error('!-- ERROR:', e)
    console.log('Is there anything to inspect?')
} finally {
}

ERROR: Error: data out-of-bounds (length=0, offset=32, code=BUFFER_OVERRUN, version=abi/5.7.0)

async loadDataUsingMulticall() {
    const { web3 } = this.state;
    var multicall = null;
    console.log("This is the mirror address:",MIRROR_ADDRESS);


    multicall = new Multicall({
      multicallCustomContractAddress: MIRROR_ADDRESS,
      nodeUrl: BSC_RPC_URL,
      web3Instance: web3,
      tryAggregate: true,
    });

    console.log("test zero");

    const contractCallContext = [
      {
        reference: "mirrorBalance",
        contractAddress: MIRROR_ADDRESS,
        abi: MIRRORABI,
        calls: [
          {
            methodName: "balanceOf",
            methodParameters: [this.state.account[0]],
          },
        ],
      },
      {
        reference: "morWholeBurn",
        contractAddress: MIRROR_ADDRESS,
        abi: MIRRORABI,
        calls: [
          {
            methodName: "balanceOf",
            methodParameters: ["0x0000000000000000000000000000000000000000"],
          },
        ],
      },
      {
        reference: "morRFIBurn",
        contractAddress: MIRROR_ADDRESS,
        abi: MIRRORABI,
        calls: [
          {
            methodName: "balanceOf",
            methodParameters: ["0x000000000000000000000000000000000000dead"],
          },
        ],
      },
      {
        reference: "totalFees",
        contractAddress: MIRROR_ADDRESS,
        abi: MIRRORABI,
        calls: [{ methodName: "totalFees", methodParameters: [] }],
      },
      {
        reference: "numFarmers",
        contractAddress: MIRROR_ADDRESS,
        abi: MIRRORABI,
        calls: [{ methodName: "numFarmers", methodParameters: [] }],
      },
    ];

    console.log("test before");
    console.log(MIRROR_ADDRESS);

    // Loop for dynamic method calls like 'farmers' and 'farmingLeaderboard'
    for (let i = 0; i < 5; i++) {
      contractCallContext.push({
        reference: `farmer${i}`,
        contractAddress: MIRROR_ADDRESS,
        abi: MIRRORABI,
        calls: [{ methodName: "farmers", methodParameters: [i] }],
      });
      contractCallContext.push({
        reference: `farmer${i}amt`,
        contractAddress: MIRROR_ADDRESS,
        abi: MIRRORABI,
        calls: [{ methodName: "farmingLeaderboard", methodParameters: [i] }],
      });
    }
    ////////////

    const callResults = await multicall.call(contractCallContext);
    console.log("test)");
    console.log(callResults);

    
    // Accessing individual results
    const mirrorBalance = Web3.utils.fromWei(
      callResults.results.mirrorBalance.callsReturnContext[0].returnValues[0],
      "ether",
    );
    const morWholeBurn = Web3.utils.fromWei(
      callResults.results.morWholeBurn.callsReturnContext[0].returnValues[0],
      "ether",
    );
    const morRFIBurn = Web3.utils.fromWei(
      callResults.results.morRFIBurn.callsReturnContext[0].returnValues[0],
      "ether",
    );
    const totalFees = Web3.utils.fromWei(
      callResults.results.totalFees.callsReturnContext[0].returnValues[0],
      "ether",
    );
    const numFarmers = parseInt(
      callResults.results.numFarmers.callsReturnContext[0].returnValues[0],
    );
    console.log("This is mirror Balance");
    console.log(mirrorBalance);
    console.log("This is morWhole Burn");
    console.log(morWholeBurn);
    console.log("This is total Farmers");
    console.log(numFarmers);
    // Loop to access farmers and farmingLeaderboard data
    let farmerData = {};
    for (let i = 0; i < 5; i++) {
      farmerData[`farmer${i}`] =
        callResults.results[`farmer${i}`].callsReturnContext[0].returnValues[0];
      farmerData[`farmer${i}amt`] =
        callResults.results[
          `farmer${i}amt`
        ].callsReturnContext[0].returnValues[0];
    }

    // Update state with all the gathered data
    this.setState({
      mirrorBalance,
      morWholeBurn,
      morRFIBurn,
      totalFees,
      numFarmers,
      ...farmerData,
      loadingLeaderBoard: false,
    });
  }

  {
        reference: 'testContract',
        contractAddress: '0xCc7bb2D219A0FC08033E130629C2B854b7bA9195',
        abi: [        {
            name: "symbol",
            type: "function",
            inputs: [{name: "", type: 'string'}],
            outputs: [
                {
                    name: "",
                    type: "string"
                }
            ],
            stateMutability: "view",

        },],
        calls: [{ reference: 'symbolCall', methodName: 'symbol', methodParameters: [42] }]
    }

callsReturnContext: [
    {
      returnValues: [],
      decoded: false,
      reference: 'symbolCall',
      methodName: 'symbol',
      methodParameters: [Array],
      success: false
    }
  ]

rror: call revert exception; VM Exception while processing transaction: reverted with reason string "Multicall3: call failed" [ See: https://links.ethers.org/v5-errors-CALL_EXCEPTION ] (method="aggregate((address,bytes)[])", data="0x08c379a0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000174d756c746963616c6c333a2063616c6c206661696c6564000000000000000000", errorArgs=["Multicall3: call failed"], errorName="Error", errorSignature="Error(string)", reason="Multicall3: call failed", code=CALL_EXCEPTION, version=abi/5.7.0)

const ethersProvider = new providers.getDefaultProvider('https://bsc-dataseed1.binance.org');
    const multicall = new Multicall({ ethersProvider: ethersProvider, multicallCustomContractAddress: '0x1Ee38d535d541c55C9dae27B12edf090C608E6Fb' });

const { Multicall } = require('ethereum-multicall');
const Web3 = require('web3');
const { abi } = require('../metadata/abi');

const options = {
  timeout: 10000, // ms
  reconnect: { auto: true, delay: 1000,  maxAttempts: 5, onTimeout: false }
};
const provider = new Web3.providers.HttpProvider('ADDRESS HERE');
const web3 = new Web3(provider, options);
const multicall = new Multicall({ web3Instance: web3, tryAggregate: true});

async function main() {
  const tokenIDs = Array.from({length: 296}, (_, i) => i + 1900);
  const calls = tokenIDs.map((token_id) => { return { methodName: 'tokenByIndex', methodParameters: [token_id] }; });
  const contractCallContext = [{ reference: 'contract', contractAddress: '0x160c404b2b49cbc3240055ceaee026df1e8497a0', abi, calls}];
  const results = await multicall.call(contractCallContext);
  const extract = results.results.contract.callsReturnContext.map((r) => r.success ? web3.utils.hexToNumber(r.returnValues[0].hex) : null);
  console.log(extract);
}

main();

const provider = new ethers.providers.JsonRpcProvider(process.env.NETWORK_URL);
const wallet = new ethers.Wallet(process.env.ACCOUNT).connect(provider);
const multicall = new ethereumMulticall.Multicall({ ethersProvider: wallet , tryAggregate: true });

const contractCallContext: ContractCallContext<{extraContext: string, foo4: boolean}>[] = [
    {
        reference: 'testContract',
        contractAddress: '0x8df3aad3a84da6b69a4da8aec3ea40d9091b2ac4',
        abi: Abi,
        calls: [{ reference: 'fooCall', methodName: 'balanceOf', methodParameters: [42] }],

    },
    {
        reference: 'testContract2',
        contractAddress: '0x1a13f4ca1d028320a707d99520abfefca3998b7f',
        abi: Abi,
        calls: [{ reference: 'fooTwoCall', methodName: 'balanceOf', methodParameters: [42] }]
    }
];

const results: ContractCallResults = await multicall.call(contractCallContext);
console.log(results);

new Multicall({ ethersProvider: new providers.Web3Provider((window as any).ethereum), tryAggregate: true })

        if (Array.isArray(decodedReturnResults)) {
            return decodedReturnResults;
        }

		if (resultData) {
			console.log("Provided block number", numberBl);
			console.log(resultData);
			return resultData;
		}
	} catch (error: any) {
		console.log(error);
	}
};
const finalData: any = (await getData()) || [];
return finalData;