Is there any API key / solidity function that would allow me to retrieve real time quotes from exchanges?
I already tried 0x API and DEX.AG but both are quite slow (1/2 calls per sec).
Yes, it is not hard but you will have to put in some work. Lets say you have 1 ETH and you want to know how much DAI the exchange will give you for it.
Example:Uniswap v2 Router:
https://etherscan.io/address/0xf164fc0ec4e93095b804a4795bbe1e041497b92a
Under 'Contracts' you can see the function getAmountsOut (Copied here to make it easier to understand)
function getAmountsOut(uint amountIn, address[] memory path) public view override returns (uint[] memory amounts) {
return UniswapV2Library.getAmountsOut(factory, amountIn, path);
}
This 'getAmountsOut' function will accept an integer amountIn, and two addresses called path.
If we input 1 for amountIn, and two addresses
WETH, DAI
[0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2, 0x6b175474e89094c44da98b954eedeac495271d0f]
the function will return the 'amounts' which is what we asked for which as of the time of writing this is 1695 DAI for 1 WETH.
Here are a couple of tutorials THAT I DID NOT WRITE that should help you get started.
UNISWAP v2: https://soliditydeveloper.com/uniswap2
MORE UNISWAP V2: https://vomtom.at/how-to-use-uniswap-v2-as-a-developer/
For automated market-makers like Uniswap, you can directly use their SDK.
Related
I am fairly new to Solidity and at this point, reviewing contracts that are active and on chain. I am trying to understand every detail. This withdraw function has got me stumped.
function withdraw(address token, uint256 amount) external onlyOwner {
if(token == address(0)) {
payable(_msgSender()).transfer(amount);
} else {
IERC20(token).transfer(_msgSender(), amount);
}
}
Particularly the two parts that are "if(token == address(0))" and "payable(_msgSender()).transfer(amount);".
The best explanation for address(0) is here What is address(0) in Solidity but I have to admit, both answers have me bewildered.
I have read that payable() is casting the address to be payable and that this has been deprecated. Just looking for a short explanation as if to a child.
A decent amount of time searching to no avail.
This code seems to aim to be an universal function for two separate features:
withdraw native token
withdraw ERC-20 token
If you pass 0x0000000000000000000000000000000000000000 as the value of address token, the code transfers amount of native token from the contract balance to the _msgSender() address. Each network has usually different native token - ETH on Ethereum, BNB on Binance Smart Chain, MATIC on Polygon, ...
If you pass any other value as address token, the contract assumes that there's an ERC-20 contract on that address, and tries to transfer out amount of the ERC-20 token from the contract balance to the _msgSender() address.
payable extension of address is not deprecated. Since Solidity v0.8.0, all native transfers need to be performed to an address payable type - while older versions also allowed transfers to the regular address type.
The use of transfer() function might be a bit confusing, though. When it's called on an address payable type, it's the native transfer. And when it's called on an interface or contract type (in your case IERC20), it invokes a function on the specified contract - in this case the external contract function is also called transfer().
I want to interact solidity simple smart contract using Golang based Go-ethereum package, which showing me the error of *types.transaction and *big.int (returning these instead of string and uint) while functions are:
function Vote() public payable returns (string memory)
function Result() public view returns (uint)
My question is how can I manage them, so that I can get exactly the same value as required.
I think this is because transaction is being performed before this function call, which may be the cause.
By your guess, you have to wait for the transaction to be mined before you can see any resulting value of the transaction.
However, in your case the results are *types.Transaction and *big.Int, this indicates that you are using the deploy-time contract instance, or not initializing the deployed contract (need RPC connection).
You can refer section "Accessing an Ethereum contract" from here, hope you can find the answer
I see that in many smart contracts address(0) is being used as shorthand for 0x0000000000....
However since it appears very often in almost all smart contracts, I am wondering if it is, or ever becomes gas efficient to simply create the variable as constant in the blockchain instead, and just reference it when necessary, or if it really is just cheaper to constantly write address(0) inline every time.
address public constant NULLADDRESS = address(0); vs using address(0) inline 50 times.
So i just tested this out with this code
pragma solidity >=0.4.22 <0.9.0;
contract NullContract{
address public constant NULLADDRESS = address(0);
function retrieve() public pure returns(address){
return (address(0));
}
}
constant NULLADDRESS needed 21442 gas
and retrieve function which returns value doesn't change anything in the blockchain needed 21420 gas. so its basically the same
I'm trying to simulate a call the transfer / transferFrom function from a certain contract without submitting it to the blockchain.
This function is used by some contracts to implement some sort of taxing system before any buy/sell.
An example of some tax implementation would be:
function transfer(address recipient, uint256 amount) public override returns (bool) {
amount = amount.mul(0.8); // tax 20%
_transfer(_msgSender(), recipient, amount);
return true;
}
The leading _transfer call is then altering the internal _balances variable with the modified amount variable.
Straight of the bat, I do not want to change the state of anything as that destroys the purpose of the simulation I'm trying to achieve.
This means that I have to use address.staticcall to call this function, since it does not alter the original state. (at least that's what I think it does, correct me if I'm wrong).
The issue now is that the transfer function does not return the modified amount variable. It only returns true or false, and this is pretty much where I get stuck.
How could I retrieve the modified amount variable? Do I need to use assembly or is there some other way of achieving this?
I would like to receive payments in any given ERC20 Token.
For that, the user must fisrt approve the transaction calling...
function approve(address, uint)
... on the Token's contract and then call to a specific function on MyContract that will triggers the actual transfer, calling...
function transferFrom(address from, address to, uint tokens)
... again on the Tokens's contract
That works fine but is very tedius and has double gas spending.
Now I found out the ERC223 standard that solves this (and other issues) but is not implemented by the mayority of the current popular tokens. It would be great to give the user the opportunity to pay just making a single transaccion when posible.
So, how can I dynamicaly check if a given token address implements ERC223 standar using web3 v0.x (im using v0.20.4) ?