Can you call a Solidity contract method with only Metamask?

Question

I’m wanting to use Metamask in my app to let users pay a fixed ETH fee (plus gas) to call a method from my Solidity contract. I looked at the Metamask documentation and the eth_sendTransaction method seems close to what I need; eth_sendTransaction would certainly allow me to request ETH from a user, but the “data” parameter is a bit confusing.

The Metamask docs say:

data is optional, but used for defining smart contract creation and interaction

and

also used for specifying contract methods and their parameters.

So “data” represents my method and its parameters, but how does Metamask (or window.ethereum, rather) know the contract whose methods I’m trying to call?

Don’t you normally have to provide a contract address and ABI/JSON in order to interact with a deployed contract? In short, is it possible to do what I’ve described with just Metamask alone? Or do you have to do other client-side setups in order to call a method with eth_sendTransaction?

Edit: by the way TylerH, the answer involved using web3.js. Maybe don't edit people's posts unless you know what the hell you're talking about. Just a thought...

Answer 1

Yes you will need the contract abi in order to get the information you need to include in the data that you're passing to the contract. There are also a few other things that you will need to accomplish this:

First you will need to make sure you download the ethers.js, and @alch/alchemy-web3 npm libraries into your application. Secondly you will need a provider API key from a platform like Alchemy in order to communicate with the contract abi. Lastly, you will need the contract abi which can be found at the bottom of the contract section of etherscan. There is plenty of information on how to obtain these things online, so I won't go over how to configure them here.

Once you have these, you are ready for the next step.

I suggest creating this in a utilities file somewhere in your applications file system, but the idea is this:

const alchemyKey = process.env.ALCHEMY_KEY;
const CONTRACT_ADDRESS = process.env.CONTRACT_ADDRESS;
const { createAlchemyWeb3 } = require("@alch/alchemy-web3");
const web3 = createAlchemyWeb3(alchemyKey);
const contractABI = require('../contract-abi.json');
export const contract = new web3.eth.Contract(contractABI, CONTRACT_ADDRESS);

export const yourMethod = () => {
 if(window.ethereum.request({method: 'eth_requestAccounts'})){
  const provider = new ethers.providers.Web3Provider(window.ethereum);
  const signer = provider.getSigner();
  const address = await signer.getAddress();

  const tx = {
   from: address,
   to: CONTRACT_ADDRESS,
   value: "some wei value", // this is the value in wei to send
   data: contract.methods.YOUR_CONTRACT_METHOD_HERE().encodeABI()
  }

  const txHash = await window.ethereum.request({
   method: 'eth_sendTransaction',
   params: [tx]
  });

  // do something with your transaction hash here
  console.log({txHash});
 }else{
   console.log('user must connect wallet');
 }
}

So the value that is populated in the data field of our transaction comes from calling the method that we are trying to invoke in our contract. This is encoded, and then we pass this information along with the rest of our transaction data.

This is a very short and brief description as to what this does, and I hope this is what you're looking for. If you need any more help I'm always available to chat on Twitter @_syndk8.