I have made 2 smart contracts to receive the sent ethers and then send it to specific wallet addresses.
First Smart Contract behavior.
When contractaddress.transfer(value) is being executed, it consumes only 9700 gas.
Trx hash - 0xb92aa187b9d6713f9f36ce5ce2edf00108703a9e9cf572d9a5143bb1631f98cb
Second Smart Contract behavior.
When contractaddress.transfer(value) is being executed, it consumes 34700 gas.
Trx hash - 0xa5d22d4db05f6851bb52a06ea2eefc12d75f242ee476f9dee3594c988b75eaa5
Why are these 2 so different? I have compiled and deployed them using Remix IDE.
Note: Above 2 contracts uses different sets of wallet addresses. I am trying to use nanopool and gaslimit provided by them is only 50k which is insufficient for Second Smart Contract since its behavior changes.
Related
I want to estimate gas of minting erc20 token without deploying contract. I am aware of contract.estimateGas but I dont have any contract address to test it. Is it possible to do it without providing contract address?
Each ERC20 contract can have different gas requirements, depending on its implementation.
Generally, token mint consists of one storage write, one event log, few memory operations, and usually one storage read (validating whether the user executing this function is authorized to mint tokens)... Which in total usually costs tens of thousands gas units.
But the actual cost is affected not only by the amount of operations but also number of functions in the contract, whether the mint function is external or public, and many other factors.
TLDR: "Usually tens of thousands of gas units" is the closest you can get without estimating against a specific implementation.
I have written a contract to mint NFT in solidity. I intend to deploy it to Polygon eventually.
There’s a slight confusion, I have put the price in my contract as 0.1 ether which works fine on Rinkeby. When I deploy the same contract on Mumbai Polygon price value 0.1 is deducted but in Matic instead of ether. Now, this makes sense because ether essentially represents the default coin of a deployed chain. My requirement is to ask users to bridge their ethers to Polygon (just like we do for OpenSea) and then pay using ether. How can I force this check that incoming value is in ether otherwise reject transaction?
use WETH to accept the payments instead of the coin of the chain, you should learn to interact with erc20 tokens in order to do what you need
I deployed my smart contract(ERC-721) on truffle (Rinkeby | Ropsten | local node) and again on Remix and I keep getting an average cost of 0.0165 ether. This gas fee seems unrealistic to me, even though my contract is pretty simple.
I finally tried deploying to MAINNET using Truffle and the transactions stopped due to a low gas value. I switched over to REMIX and the new total gas fee is 0.65 ($2500) ether.
Is this a realistic amount to deploy a smart contract? or do I need to change some setting on remix?
Do the testnet's give a good representation of what gas fee will cost on mainnet ?
The amount of gas used from gas limit, not the gas price is going to be consistent between mainnet and testnets as the gas used from gas limit represents the amount of work that needs to be done to process the transaction logic in the EVM. Gas price (how much you pay for a unit of gas used) fluctuates as it is dependent on market economics/game theory, which is going to be very different on a test network vs live network.
References
https://ethereum.org/en/developers/docs/gas/
Is it possible to store gas that is not used inside a contract, so it can be used at a later time (presuming it is possible to require a certain amount of gas calling a function)?
I am trying to write a contract that requires user input and does something based upon that input at a later moment in time that will require gas.
As it does not sound really attractive to pay that gas out of the contract owners pocket I am looking for a way to make the user of the contract pay for the gas it needs to complete the request.
In fact, it is really possible to store gas in a contract for later use.
There are some operations in EVM that can return some gas that was payed before:
SSTORE: changing storage value from non-zero to zero releases 15000 gas
SELFDESTRUCT: destroying contract releases 24000 gas
That means that e.g. storing some value requires 20k gas, but deleting it form storage requires only 5k gas and releases 15k gas for later usage in the same transaction. Actually this is a reward for clearing up blockchain storage.
You can get more details by searching "refund" in Yellowpaper.
There is GasToken project that uses this very feature to store gas in contract when it is cheap and release (and use) when it is expensive.
To be clear, I don't think this allows user to issue transactions without paying gas at all.
Seems like you have mixed up a little bit the meaning of gas.
The gas is the Ether you have to pay to have your transaction mined. The gas is always paid by the address that calls the function(Contract) and not from the Contract itself or the owner of the Contract so it doesn't come out of the owners pocket. Also gas is basically ether so "storing gas" is to store Ether in a contract but you cannot store the gas that is used to mine the transaction. If you want to store Ether you have to send Ether to the Contract or have the users send Ether when they call a function.
I want to get all receipt records of some address (address A) from blockchain. I use web3.eth.getBlock and web3.eth.getTransaction to get all transactions related to A.
But I find if ethers are transfered to address A by invoking 'A.send' or 'A.transfer' function in contract, I can only get a contract call transaction which from caller address to contract address. And I can't find relationship between this transaction and address A.
Is there any way to get transactions invoked by contract for A?
Thanks.
Short answer: listen to events instead of monitoring transactions.
Why can't I find the transactions "invoked by" the contract?
A contract does not invoke/create its own transaction (it doesn't have a private key to sign one). A contract can call other contracts during its own execution, as you've seen, but those calls are all executed as part of the same transaction.
The recommended way to discover executed function calls is to use events. If the contract you want to watch does not specify an event on the call you want to watch, you may be in for some heavy lifting: tracing every transaction's execution at the EVM level (something that big block explorers do to generate some of the extra info they provide).
If you are stuck tracing: you can find more about using ethereumjs-vm or geth's debug_traceTransaction on this Ethereum StackExchange Question about internal transactions.