3 min de lectura
Metamask: Sign TX with metamask and generate TxHash before sending to node
CRYPTOCURRENCY
Using metamascus for signature of transactions and generating stiffness txhash
When designing an ERC20 payment system, you will want to make sure that user transactions are safe and reliable. One of the ways to do this is to use Metamask’s wallet and its integration with Blockchain Ethereum. In this article we will study how to use Metamk to sign transactions with the ERC20 contract and generate TXHash.
What is Metamk?
Metamask is a popular web browser extension that allows users to safely store their private keys on their device. It supports several wallets, including metamask and provides features such as automatic key storage, without recording passwords and trouble -free switching between the type of wallet.
Generation TXHash with Metamask
To generate TXHash, you will need to use the «transaction» function in stability that is part of the Ethereum programming language. Here is an example of how to create an agreement using a metamaSy:
`Solidity
Pragma of solidity ^0.6.0;
Contract myaERC20 {
// Define the address of the agreement and the tag details
Address Public Constant my_Contract_address = «0x …»; // replace the contract address
The public name of the chains;
Uint8 public symbol;
UIINT256 Summary of Public;
// function to create a new agreement
SENDTXHash function (address recipient, byte data data) public {
// Use Metamku to generate TXHash and sign a transaction
Baiti32 txide = keccak256 (both.encodepacked (recipient, data));
String Memory TXHash = both .encode (txid) .hex ();
// Save the transaction to the database
radiation transmission (MyContractaddress, recipient, TXHash);
}
}
`
In this example, we define the «SendtxHash» function, which creates a new agreement using Metamask. We use keccak256 to generate hash based on the address and data of the recipient (in this case an empty string). The resulting TXHash is then placed in the database.
Signature with Metamass
To sign an agreement with Metamko, you will need to follow the following steps:
- Open Metamk on your device.
- Select the contract you want to use for transactions (eg «myerc20
).
- Click "Send" and select the addressee's address and data (in this case an empty string).
- Metamk automatically generates TXHash and signs an agreement with its private key.
Generation TXHash from behind
You can use a feature that gets the hash transactions from the blockchain to generate TXHash from behind and store it in the database. Here is an example of how to do this:
Solidity
Pragma of solidity ^0.6.0;
Contract myaERC20 {
// Define the address of the agreement, the marker and the deposition of the database
Address Public Constant my_Contract_address = «0x …»; // replace the contract address
The public name of the chains;
Uint8 public symbol;
UIINT256 Summary of Public;
mapping (address => mapping (uint256 => byte32)) publicly TXHASHES;
// function to get a hash agreement from the database
GetTxHash function (address sender, UInt256 tokenindex) public viewing Returns (Byte32) {
// Use a contract or library that loads hash transactions from blockchain
Return TXHASHES [consignor] [tokenindex];
}
}
`
In this example, we define the «GetTxHash» function, which considers the sender’s address and tokens index to be arguments. Then we use a different feature to get TXHash from the database using the Ethereum blockchain.
Example of using
Here is an example of how you can use a metamass with an ERC20 contract:
`Solidity
Pragma of solidity ^0.6.0;
Contract myaERC20 {
// Define the address of the agreement, the marker and the deposition of the database
Address Public Constant my_Contract_address = «0x …
