Verify a (Metamask) transaction has happened on NodeJS

Question

What is the best way to verify a (Metamask) transaction has happened on NodeJS?

Use case:

A user buys a digital card with ether. After the user buys the digital card, a route on the server runs some code, makes a PDF, etc..

What is the recommended way to have a server (ExpressJS) verify that a tx has happened and is successful?

I was thinking of two options, but I'm pretty new to Ethereum so I'm probably missing some details here.

1. Have the server listen to events from the contract. When an event comes in, it'll have the user's address and prove they paid. Than I can make the card.

The only thing that I'm concerned here with is that maybe some details of the card are private. And if it's in the logs, it'll be public. 🤔

or..

2. OR have the user sign the message locally, push it to the server and somehow send it to the contract. I'm not sure what the details are with this route.

Are there any recommended ways to accomplish something like this?

Answer 1

I followed the below approach for a use case in which transactions were generated from a front-end using React.js and Metamask and a back-end with Node.js:

1. Transaction creation [React.js]: the user performs an action (e.g.: buy a digital card) in the website that triggers a call to a smart contract that needs to be confirmed with Metamask. The call should look something like this:

    // Transaction parameters
    const txParams = {
        from: fromAccount,
        to: toAccount,
        data: encodedData,
        value: (action === Action.SWAP_TRANSFER_ETH) ? value : 0,
        chainId: chainId,
    };
   
    // Transaction execution in Ethereum from Metamask
    await window.ethereum.request({
        method: 'eth_sendTransaction',
        params: [txParams],
    })
        .then(async (tx: string) => {
         // Actions from step 2
    }
   

2. Transaction submission to back-end [React.js]: once the transaction is created, you can send the transaction hash to the backend together with any further information you might need to store. In my case, I used axios to post data into Node.js:

            // Transaction details (extended)
            const params = {
                from: fromAccount,
                to: toAccount,
                txHash: tx,
                chainId: chainId,
                status: 'pending',
                lastUpdate: moment().unix()
                //... other fields
            };
   
            // Post tx data
            await axios.post(`${URL()}/ethereum/send`, params)
                .then(res => {
                    // Show logs
                })
   

3. Transaction confirmation in back-end [Node.js]: here is where you need to check whether the transaction has been effectively confirmed, which means that you need to wait for a certain number of blocks validated after your transaction to avoid a potential chain reorganisation. In this answer I give background information on how to validate a transaction from Node.js:

ETH transactions confirmations counting

Finally, I was using a database to store data regarding the users' orders. In general, it is not recommended to store any sensitive data into the blockchain, and if you need to do so, it is better to hash the data and use it only as reference to ensure the integrity between what you stored in the database and the hash stored in the blockchain (e.g: in case you need traceability of your orders).

Regarding the number of confirmations required... not sure there is a global consensus, but have read around 10 to 12. It depends on how long you accept to wait and how important is to ensure the confirmations.

Hope this gives you an overall idea.