Why am I receiving the following Chainlink error: cannot estimate gas - blockchain
I am trying to follow the Chainlink VRF tutorial found here: https://docs.chain.link/docs/intermediates-tutorial/ with hardhat and am running into this issue when calling the rollDice function:
Error: cannot estimate gas; transaction may fail or may require manual gas limit (error={"reason":"cannot estimate gas; transaction may fail or may require manual gas limit","code":"UNPREDICTABLE_GAS_LIMIT","method":"estimateGas","transaction":{"from":"0x014Da1D627E6ceB555975F09D26B048644382Ac6","maxPriorityFeePerGas":{"type":"BigNumber","hex":"0x9502f900"},"maxFeePerGas":{"type":"BigNumber","hex":"0x9502f90e"},"to":"0x5887946875A01D1BB79d6Fb357BceeA5A0096D2e","data":"0xdd02d9e5000000000000000000000000014da1d627e6ceb555975f09d26b048644382ac6","type":2,"accessList":null}}, tx={"data":"0xdd02d9e5000000000000000000000000014da1d627e6ceb555975f09d26b048644382ac6","to":{},"from":"0x014Da1D627E6ceB555975F09D26B048644382Ac6","type":2,"maxFeePerGas":{"type":"BigNumber","hex":"0x9502f90e"},"maxPriorityFeePerGas":{"type":"BigNumber","hex":"0x9502f900"},"nonce":{},"gasLimit":{},"chainId":{}}, code=UNPREDICTABLE_GAS_LIMIT, version=abstract-signer/5.5.0)
at Logger.makeError (/Users/matt/Desktop/hardhat/randomDay/node_modules/#ethersproject/logger/src.ts/index.ts:225:28)
at Logger.throwError (/Users/matt/Desktop/hardhat/randomDay/node_modules/#ethersproject/logger/src.ts/index.ts:237:20)
at /Users/matt/Desktop/hardhat/randomDay/node_modules/#ethersproject/abstract-signer/src.ts/index.ts:301:31
at processTicksAndRejections (node:internal/process/task_queues:96:5)
at async Promise.all (index 7)
I am able to deploy to the Kovan testnet, I was able to verify the contract, and I have sent the contract LINK tokens, but am still running into the issue. The contract can be viewed here: https://kovan.etherscan.io/address/0x7b72d80670512c87605ab8ac7e6113fda9c57de4#code
I am using version 0.8 of the Chainlink Contracts.
RandomDay.sol
pragma solidity ^0.8.9;
import "#chainlink/contracts/src/v0.8/VRFConsumerBase.sol";
contract RandomDay is VRFConsumerBase {
uint256 private constant ROLL_IN_PROGRESS = 42;
bytes32 private s_keyHash;
uint256 private s_fee;
mapping(bytes32 => address) private s_rollers;
mapping(address => uint256) private s_results;
event DiceRolled(bytes32 indexed requestId, address indexed roller);
event DiceLanded(bytes32 indexed requestId, uint256 indexed result);
constructor(address vrfCoordinator, address link, bytes32 keyHash, uint256 fee) VRFConsumerBase(vrfCoordinator, link) {
s_keyHash = keyHash;
s_fee = fee;
}
function rollDice (address roller) public returns (bytes32 requestId) {
require(LINK.balanceOf(address(this)) >= s_fee, "Not enough LINK to pay fee");
require(s_results[roller] == 0, "Already rolled");
requestId = requestRandomness(s_keyHash, s_fee);
s_rollers[requestId] = roller;
s_results[roller] = ROLL_IN_PROGRESS;
emit DiceRolled(requestId, roller);
return requestId;
}
function fulfillRandomness (bytes32 requestId, uint256 randomness) internal override {
uint256 dayOfWeek = (randomness % 7) + 1;
s_results[s_rollers[requestId]] = dayOfWeek;
emit DiceLanded(requestId, dayOfWeek);
}
function weekday (address player) public view returns (string memory) {
require(s_results[player] != 0, "Dice not rolled");
require(s_results[player] != ROLL_IN_PROGRESS, "Roll in progress");
return getWeekdayName(s_results[player]);
}
function getWeekdayName (uint256 id) private pure returns (string memory) {
string[7] memory weekdays = [ "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
return weekdays[id - 1];
}
}
hardhat.config.js
/**
* #type import('hardhat/config').HardhatUserConfig
*/
require("#nomiclabs/hardhat-waffle")
require("#nomiclabs/hardhat-etherscan")
const ALCHEMY_API_KEY = "*************************";
const ROPSTEN_PRIVATE_KEY = "*********************";
module.exports = {
solidity: "0.8.9",
networks: {
kovan: {
url: `https://eth-kovan.alchemyapi.io/v2/${ALCHEMY_API_KEY}`,
accounts: [`0x${ROPSTEN_PRIVATE_KEY}`],
gas: 2700000000,
maxFeePerGas: 30000000000,
}
},
etherscan: {
// Your API key for Etherscan
// Obtain one at https://etherscan.io/
apiKey: "****************************"
}
};
deploy.js
const { ethers } = require("hardhat");
async function main() {
const [deployer] = await ethers.getSigners();
console.log("Deploying contracts with the account:", deployer.address);
console.log("Account balance:", (await deployer.getBalance()).toString());
const Token = await ethers.getContractFactory("RandomDay");
const token = await Token.deploy("0xa36085F69e2889c224210F603D836748e7dC0088", "0xdD3782915140c8f3b190B5D67eAc6dc5760C46E9", "0x6c3699283bda56ad74f6b855546325b68d482e983852a7a82979cc4807b641f4", "100000000000000000");
console.log("Token address:", token.address);
}
main()
.then(() => process.exit(0))
.catch((error) => {
console.error(error);
process.exit(1);
});
quickRun.js
var ethers = require('ethers');
var provider = ethers.providers.getDefaultProvider('kovan');
var address = '0x7b72d80670512c87605aB8aC7E6113Fda9c57de4';
var abi = [{"inputs":[{"internalType":"address","name":"vrfCoordinator","type":"address"},{"internalType":"address","name":"link","type":"address"},{"internalType":"bytes32","name":"keyHash","type":"bytes32"},{"internalType":"uint256","name":"fee","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"requestId","type":"bytes32"},{"indexed":true,"internalType":"uint256","name":"result","type":"uint256"}],"name":"DiceLanded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"requestId","type":"bytes32"},{"indexed":true,"internalType":"address","name":"roller","type":"address"}],"name":"DiceRolled","type":"event"},{"inputs":[{"internalType":"bytes32","name":"requestId","type":"bytes32"},{"internalType":"uint256","name":"randomness","type":"uint256"}],"name":"rawFulfillRandomness","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"roller","type":"address"}],"name":"rollDice","outputs":[{"internalType":"bytes32","name":"requestId","type":"bytes32"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"player","type":"address"}],"name":"weekday","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"}];
var privateKey = '*******************************';
var wallet = new ethers.Wallet(privateKey, provider);
var contract = new ethers.Contract(address, abi, wallet);
var sendPromise = contract.rollDice('0x014Da1D627E6ceB555975F09D26B048644382Ac6');
sendPromise.then(function(transaction){
console.log(transaction);
});
I believe the addresses are off:
Constructor Arguments of your contract:
-----Decoded View---------------
Arg [0] : vrfCoordinator (address): 0xa36085f69e2889c224210f603d836748e7dc0088
Arg [1] : link (address): 0xdd3782915140c8f3b190b5d67eac6dc5760c46e9
Arg [2] : keyHash (bytes32): 0x6c3699283bda56ad74f6b855546325b68d482e983852a7a82979cc4807b641f4
Arg [3] : fee (uint256): 100000000000000000
Via Chainlinks Docs:
LINK 0xa36085F69e2889c224210F603D836748e7dC0088
VRF Coordinator 0xdD3782915140c8f3b190B5D67eAc6dc5760C46E9
Key Hash 0x6c3699283bda56ad74f6b855546325b68d482e983852a7a82979cc4807b641f4
Fee 0.1 LINK
Switched Link and VRF are probably the culprit.
9 out of 10 is because you passed something wrong in the constructor or something in the contructor is not initialized propertly. this kind of things aren't detected by compiler.
Related
transaction fails when I call getRandomNumber() function from chainlink VRF v1
I am using chainlink VRF v1 to get a random number. I am using ethers.js to call the getRandomNumber() function but it always fails with this message: Error: transaction failed [ See: https://links.ethers.org/v5-errors-CALL_EXCEPTION ] I have enought LINK in my contract so that is not the reason for this. Is there any other possible or anything wrong with my code? my smart contract: // SPDX-License-Identifier: MIT pragma solidity ^0.8.12; import "#chainlink/contracts/src/v0.8/VRFConsumerBase.sol"; contract VRFConsumer is VRFConsumerBase { bytes32 keyHash; uint256 requiredFee; uint256 public randomResult; constructor() VRFConsumerBase( 0x844ECf0B33EB65e1EC34AEa0d082D39879169890, 0xa36085F69e2889c224210F603D836748e7dC0088 ) { keyHash = 0x6c3699283bda56ad74f6b855546325b68d482e983852a7a82979cc4807b641f4; requiredFee = 0.1 * 10**18; } function getRandomNumber() public returns (bytes32 requestId) { require( LINK.balanceOf(address(this)) >= requiredFee, "Not enough LINK - fill contract with faucet" ); return requestRandomness(keyHash, requiredFee); } function fulfillRandomness( bytes32, /*requestId*/ uint256 randomness ) internal override { randomResult = randomness; } } my frontend code: const provider: ethers.providers.Web3Provider = new ethers.providers.Web3Provider((window as any).ethereum; ); const signer: ethers.providers.JsonRpcSigner = provider.getSigner(); const vrfConsumer = new ethers.Contract( this.address, vrfConsumerABI, provider ); console.log("Start"); const vrfConsumerWithSigner = vrfConsumer.connect(signer); const tx = await vrfConsumerWithSigner.getRandomNumber({ gasPrice: 3000000000, gasLimit: 2000000, }); await tx.wait(); const result: BigNumber = await vrfConsumer.randomResult(); console.log(result.toNumber()); console.log("done");
I suggest you to check some functions in Chainlink hardhat-starter-kit helper-functions.js tasks\random-number-consumer\request-random-number.js tasks\random-number-consumer\read-random-number.js
Transaction fails with CALL_EXCEPTION whenever I try to mint an NFT using ethers.js
I am using ethers.js to call the mint function in my smart contract but it fails with this error: Error: transaction failed [ See: https://links.ethers.org/v5-errors-CALL_EXCEPTION ]. I am able to call the view functions this error only occurs when I call functions which make transactions. So, I know that I have connected to the same network as the contract. My smart contract: pragma solidity ^0.8.12; import "#openzeppelin/contracts/token/ERC721/ERC721.sol"; import "#openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol"; import "#openzeppelin/contracts/access/Ownable.sol"; contract FutNFT is ERC721, ERC721Enumerable, Ownable { struct Player { string name; string preferredPosition; uint256 id; uint8 age; uint8 level; uint64 lastUpgrade; string[] suitablePositions; string imageURI; } struct History { uint256 winCount; uint256 lossCount; } mapping(address => History) ownerHistory; mapping(uint256 => Player) players; mapping(uint256 => address) public playerToOwner; mapping(uint256 => uint256) listedPlayerIndex; uint256[] public listedPlayers; event PlayerAdded(uint256 playerId); modifier owned(uint256 id) { require(getPlayerExists(id), "Player does not exist"); require(msg.sender == ownerOf(id), "Not the owner!"); _; } constructor() ERC721("FutNFT", "FNFT") {} function getListedPlayers() public view returns (uint256[] memory) { return listedPlayers; } function getPlayer(uint256 _id) public view returns (Player memory) { return players[_id]; } function ownerOf(uint256 tokenId) public view override(ERC721, IERC721) returns (address) { return super.ownerOf(tokenId); } function getPlayerExists(uint256 _id) public view returns (bool) { return playerToOwner[_id] != address(0); } function mint(Player memory _player) public onlyOwner { require(playerToOwner[_player.id] == address(0), "Player Exists!"); players[_player.id] = _player; playerToOwner[_player.id] = msg.sender; _mint(msg.sender, _player.id); emit PlayerAdded(_player.id); } function _beforeTokenTransfer( address from, address to, uint256 tokenId ) internal override(ERC721, ERC721Enumerable) { super._beforeTokenTransfer(from, to, tokenId); } function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) { return super.supportsInterface(interfaceId); } } my frontend code: const player: PlayerInterface = { name: "Lionel Messi", preferredPosition: "RWF", id: 1, age: 34, level: 20, lastUpgrade: new Date().getTime(), suitablePositions: ["ST", "CF", "RMF", "CAM"], imageURI: "https://bafybeicfhmevzs4aso7rqvx7l5ndb2ly7gudjyj5xjkztvohpwxw2za7iy.ipfs.dweb.link/nft.png", }; const provider = new ethers.providers.Web3Provider( (window as any).ethereum ); const signer = provider.getSigner(); const tx = await futNFT.connect(signer).mint(player, { gasPrice: 30000000000, gasLimit: 2000000, }); await tx.wait(); console.log("minted"); const player1 = await futNFT.getPlayer(1); console.log(player1);
TypeError: Cannot destructure property 'interface' of 'require(...)' as it is undefined
test.js file. I've tried installing/ uninstalling all different/previous versions of solidity but nothing is working properly. I am getting this TypeError: Cannot destructure property 'interface' of 'require(...)' as it is undefined. repeatedly. Please help me regarding this problem const assert = require("assert"); const ganache = require("ganache-cli"); const Web3 = require("web3"); const web3 = new Web3(ganache.provider()); const { interface, bytecode } = require('../compile'); let lottery; let accounts; beforeEach(async () => { accounts = await web3.eth.getAccounts(); lottery = await new web3.eth.Contract(JSON.parse(interface)) .deploy({ data: bytecode }) .send({ from: accounts[0], gas: "1000000" }); }); describe('Lottery Contract', () => { it('deploys a contract', () => { assert.ok(lottery.options.address); }); }); compile.js file. Error while I try to run my compile.js file. Using command "npm run test". Please help me regarding this problem. const path = require("path"); const fs = require("fs"); const solc = require("solc"); const lotteryPath = path.resolve(__dirname, "contracts", "Lottery.sol"); const source = fs.readFileSync(lotteryPath, "utf8"); // console.log(solc.compile(source, 1)); module.exports = solc.compile(source, 1).contracts[":Lottery"]; deploy.js file const HDWalletProvider = require("#truffle/hdwallet-provider"); const Web3 = require("web3"); const { interface, bytecode } = require("./compile"); const provider = new HDWalletProvider( "**************************************************", "https://rinkeby.infura.io**************************" ); const web3 = new Web3(provider); const deploy = async () => { const accounts = await web3.eth.getAccounts(); console.log("Attempting to deploy from accoutns", accounts[0]); const result = await new web3.eth.Contract(JSON.parse(interface)) .deploy({ data: bytecode}) .send({ gas: "1000000", from: accounts[0] }); console.log("Contract deployed to", result.options.address); }; lottery.sol file pragma solidity ^0.8.7; // latest solidity version... contract Lottery { address public manager; address[] public players; constructor() { manager = msg.sender; } function enter() public payable { require(msg.value > .01 ether); players.push(msg.sender); } function random() private view returns (uint256) { return uint256(keccak256(abi.encodePacked(block.difficulty, block.timestamp, players))); } function pickWinner() public restricted { require(msg.sender == manager); uint256 index = random() % players.length; uint256 amount = address(this).balance; payable(players[index]).transfer(amount); players = new address[](0); } modifier restricted() { require(msg.sender == manager); _; } function getPlayers() public view returns (address[] memory) { return players; } }
Internal JSON-RPC error with MetaMask on Polygon Blockchain. `ERC721: transfer caller is not owner nor approved.`
I am making an NFT marketplace. When I deployed my contract on the Mumbai-testnet. The createToken function might work cause it brings up the Metamask for the Gas Fee but after that, the Error occurs something regarding the ONWNERSHIP. (Error image and text is present below.) STEPS which I follow npm hardhat node npm run dev Selecting the Creating Page. Enter all the details. Click on Create an Asset which calls the createToken function. then the error occurs. Here is my NFT contract contract NFT is ERC721URIStorage { using Counters for Counters.Counter; Counters.Counter private _tokenIds; address contractAddress; constructor(address marketplaceAddress) ERC721("Metaverse Tokens", "METT") { contractAddress = marketplaceAddress; } function createToken(string memory tokenURI) public returns (uint256) { _tokenIds.increment(); uint256 newItemId = _tokenIds.current(); _mint(msg.sender, newItemId); _setTokenURI(newItemId, tokenURI); setApprovalForAll(contractAddress, true); return newItemId; }} Here is my NFTMarket contract contract NFTMarket is ReentrancyGuard { using Counters for Counters.Counter; Counters.Counter private _itemIds; Counters.Counter private _itemSold; address payable owner; uint256 listingPrice = 0.025 ether; // Here ether is denoting the MATIC constructor() { owner = payable(msg.sender); } struct MarketItem { uint256 itemId; address nftContract; uint256 tokenId; address payable seller; address payable owner; uint256 price; bool sold; } mapping(uint256 => MarketItem) private idToMarketItem; event MarketItemCreated( uint256 indexed itemId, address indexed nftContract, uint256 indexed tokenId, address seller, address owner, uint256 price, bool sold ); function getListingPrice() public view returns (uint256) { return listingPrice; } //Function to create an NFT function createMarketItem( address nftContract, uint256 tokenId, uint256 price ) public payable nonReentrant { //Conditions for creating the Item. require(price > 0, "Price must be at least 1 wei"); require( msg.value == listingPrice, "Price must be equal to listing price" ); _itemIds.increment(); uint256 itemId = _itemIds.current(); idToMarketItem[itemId] = MarketItem( itemId, nftContract, tokenId, payable(msg.sender), payable(address(0)), // When new NFT is created its ownership add is set to 0. price, false ); IERC721(nftContract).transferFrom(msg.sender, address(this), tokenId); //Trigger the Event emit MarketItemCreated( itemId, nftContract, tokenId, msg.sender, address(0), price, false ); } //Function to Transfer the Ownership function createMarketSale(address nftContract, uint256 itemId) public payable nonReentrant { uint256 price = idToMarketItem[itemId].price; uint256 tokenId = idToMarketItem[itemId].tokenId; require( msg.value == price, "Please submit the asking value in order to Purchase" ); //Will transfer the MATIC to the seller address. idToMarketItem[itemId].seller.transfer(msg.value); //Will transfer the ownership from the owner of this contract to the Buyer. IERC721(nftContract).transferFrom(address(this), msg.sender, tokenId); //Set the local value of the owner to the Buyer(msg.sender). idToMarketItem[itemId].owner = payable(msg.sender); //Set this NFT as sold. idToMarketItem[itemId].sold = true; _itemSold.increment(); payable(owner).transfer(listingPrice); } //Returns number of items unsold function fetchMarketItems() public view returns (MarketItem[] memory) { uint256 itemCount = _itemIds.current(); uint256 unsoldItemCount = _itemIds.current() - _itemSold.current(); uint256 currentIndex = 0; MarketItem[] memory items = new MarketItem[](unsoldItemCount); for (uint256 i = 0; i < itemCount; i++) { if (idToMarketItem[i + 1].owner == address(0)) { uint256 currentId = idToMarketItem[i + 1].itemId; MarketItem storage currentItem = idToMarketItem[currentId]; items[currentIndex] = currentItem; currentIndex += 1; } } return items; } //Returns number of Own(Created or Bought) NFTs function fetchMyNFTs() public view returns (MarketItem[] memory) { uint256 totalItemCount = _itemIds.current(); uint256 itemCount = 0; uint256 currentIndex = 0; for (uint256 i = 0; i < totalItemCount; i++) { if (idToMarketItem[i + 1].owner == msg.sender) { itemCount += 1; } } MarketItem[] memory items = new MarketItem[](itemCount); for (uint256 i = 0; i < totalItemCount; i++) { if (idToMarketItem[i + 1].owner == msg.sender) { uint256 currentId = idToMarketItem[i + 1].itemId; MarketItem storage currentItem = idToMarketItem[currentId]; items[currentIndex] = currentItem; currentIndex += 1; } } return items; } //Returns the no of NFT created function fetchItemsCreated() public view returns (MarketItem[] memory) { uint256 totalItemCount = _itemIds.current(); uint256 itemCount = 0; uint256 currentIndex = 0; for (uint256 i = 0; i < totalItemCount; i++) { if (idToMarketItem[i + 1].seller == msg.sender) { itemCount += 1; } } MarketItem[] memory items = new MarketItem[](itemCount); for (uint256 i = 0; i < totalItemCount; i++) { if (idToMarketItem[i + 1].seller == msg.sender) { uint256 currentId = idToMarketItem[i + 1].itemId; MarketItem storage currentItem = idToMarketItem[currentId]; items[currentIndex] = currentItem; currentIndex += 1; } } return items; }} I tried changing the RPC in the MetaMask and the configuration files and redeployed it many times with different accounts, but still, nothing changes. The Error MetaMask - RPC Error: Internal JSON-RPC error. data: code: 3 message: "execution reverted: ERC721: transfer caller is not owner nor approved" Image of the console If any other info is required please comment Link of Blockchain Explorer
Thank You for your efforts. I got the solution to it(After Searching for 3 days). SOLUTION=> There's currently a bug on Mumbai causing deployed addresses to be incorrect. This is causing the constructor of the NFT contract to approve the wrong address for NFT purchases (because it uses the address of the Market deployment for approval) — causing the annoying "execution reverted: ERC721: approve caller is not owner nor approved for all" error. Try using Mainnet (yes, you'll have to use real money) but it works! Reference Here's a workaround deploy script that will make it work on Mumbai. Replace main() in deploy.js with: const hre = require("hardhat"); async function main() { const [deployer] = await hre.ethers.getSigners(); console.log( "Deploying contracts with the account:", deployer.address ); let txHash, txReceipt const NFTMarket = await hre.ethers.getContractFactory("NFTMarket"); const nftMarket = await NFTMarket.deploy(); await nftMarket.deployed(); txHash = nftMarket.deployTransaction.hash; txReceipt = await ethers.provider.waitForTransaction(txHash); let nftMarketAddress = txReceipt.contractAddress console.log("nftMarket deployed to:", nftMarketAddress); const NFT = await hre.ethers.getContractFactory("NFT"); const nft = await NFT.deploy(nftMarketAddress); await nft.deployed(); txHash = nft.deployTransaction.hash; // console.log(`NFT hash: ${txHash}\nWaiting for transaction to be mined...`); txReceipt = await ethers.provider.waitForTransaction(txHash); let nftAddress = txReceipt.contractAddress console.log("nft deployed to:", nftAddress); } main() .then(() => process.exit(0)) .catch((error) => { console.error(error); process.exit(1); }); Redeploy the Contracts with this Script, and change the config.js.
I checked your full code and it is working. You are inheriting from ERC721URIStorage which inherits from ERC721 If you check the transferFrom inside ERC721: function transferFrom(address from,address to,uint256 tokenId ) public virtual override { // ***** THIS REQUIRE IS NOT SATISFIED ***** require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved"); _transfer(from, to, tokenId); } you are getting that error, because require statement inside transferFrom is not satisfied. this is the _isApprovedOrOwner function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) { require(_exists(tokenId), "ERC721: operator query for nonexistent token"); address owner = ERC721.ownerOf(tokenId); return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender)); } this function is not returning True. in order to get True, this spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender) should return True. in or operations in order to get True, 3 of conditions must be True. In my opinion, you are trying to transfer a token that is not yours.
During development, every time you compile your smart contract (using something like hardhat compile..) , you have to copy the new smart contract addresses generated in your command prompt and paste them in the designated location in your source code.
How to transfer ERC1155 token using web3js?
I am trying to transfer ERC1155 tokens to another account. I have deployed the contract and have put down my contract code below. The problem I am facing is I get the below error when I call getMyToken function from my frontend web3js code. {code: -32603, message: 'execution reverted: ERC1155: caller is not owner nor approved', data: {…}} Not sure what is happening. I am calling the function as below from frontend. The isApproved function is returning true. const selectedAccountIsApproved = await monkeysContract.methods.isApproved(selectedAccount).call(); console.log('IS APPROVED RESULT: ', selectedAccountIsApproved); if(selectedAccountIsApproved) { const result = await monkeysContract.methods.mintMyMonkey(selectedAccount, 0).call(); console.log('Transfer Result: ', result); } else { console.log('Account not approved by owner for transfers'); } NOTE: I have called the setApprovalForAll method and approved the receiver account. I am able to call isApprovedForAll and verify that the account is approved. I am able to transfer tokens to the receiver through Etherscan contract interface. Contract Code: // SPDX-License-Identifier: MIT pragma solidity ^0.6.0; import "#openzeppelin/contracts/token/ERC1155/ERC1155.sol"; import "#openzeppelin/contracts/access/Ownable.sol"; contract Monkeys is ERC1155, Ownable { uint256 public constant CC1 = 0; uint256 public constant CC2 = 1; mapping (uint256 => string) private _uris; constructor() public ERC1155("https://game.example/api/item/{id}.json") { _mint(msg.sender, CC1, 1000, ""); _mint(msg.sender, CC2, 1000, ""); } function uri(uint256 tokenId) override public view returns (string memory) { return(_uris[tokenId]); } function setTokenUri(uint256 id, string memory url) public onlyOwner { require(bytes(_uris[id]).length == 0, "Cannot set uri twice"); _uris[id] = url; } function transfer(address from, address to, uint256 id, uint256 amount, bytes memory data) public { safeTransferFrom(from, to, id, amount, data); } function isApproved(address user) public view virtual returns (bool) { return isApprovedForAll(owner(), user); } function getMyToken(address to, uint256 id) public { transfer(owner(), to, id, 1, 'test'); } }