New answers tagged transactions
0
The more realistic situation will be to send from 100 different addresses.
From an ethereum client perspective there is some difference but not much.
For a miner it should not matter. Once the proposed block is created by the client the proof of work algorithm execution will be the same.
0
Relays are not part of the protocol. They are an emerging pattern for user-facing UI's that simplify user-onboarding by adding flexible payment options for the gas. Users can transfer tokens and interact with contracts without having any ether.
Suppose Alice wants to send a transaction to a Contract using Bob to relay the transaction.
Alice signs the ...
0
You use Whisper (https://github.com/ethereum/go-ethereum/wiki/Whisper)
Solution using Web3.py:
I have followed following ssh-mode code.
receiver.py that runs on node-1:
from web3 import Web3, HTTPProvider
web3 = Web3(HTTPProvider('http://localhost:8545'))
from web3.shh import Shh
Shh.attach(web3, "shh")
import time, sys;
from hexbytes import (
...
0
If you are using web3js, look at web3.eth.subscribe function. It implements asynchronous notifications about various blockchain events, such as new blocks or event logs. Under the hood it just polls the node periodically, as geth doesn't support push notifications.
For token transfers you need to subscribe to transfer event. For ether transfer things are ...
0
Websockets
I'd recommend this page for an overview of the different flags you can use with Geth on launch. It mentions there that the default address for the websocket (if turned on with --ws) is localhost:8546.
Logging all transactions
I don't think this will output all new txs out-of-the-box, though I am a bit out of my water here. You could use a ...
-2
Use EMSA - service that allows transmitting any information, from texts and images to encrypted files and HTML pages.
1
According to your link to etherscan, the transaction is:
From: 0x2b9c37a4a6f27a95a790a9935a998123167425f0
To: Contract 0x5d3a536e4d6dbd6114cc1ead35777bab948e3643
And the method invoked on that contract is:
Function: redeem(uint256 redeemTokens)
This function calls another function and so on, but the important part is that at some point during the ...
0
Let me try to put this in a simpler way:
When MultiSigWallet is deployed it takes an array of owners and the number of confirmations required for executing a transaction.
function MultiSigWallet(address[] _owners, uint _required){ //Logic }
The purpose of multisig wallets is to increase security by requiring multiple parties to agree on transactions ...
0
The closest you can do is sending some ether back to the sender of the transaction in order to compensate him/her for the gas the he/she has paid for that transaction.
You can do this by executing msg.transfer(<someValue>) inside the desired function.
Nevertheless, as you can understand from the description above, the sender must have some ether in ...
0
Here is refined TypeScript code that also
Allows you to wait for N confirmations for the transaction to be mined
Checks if the transaction, after mined, was successful or not
The code is based on the example and Github MIT sources.
/**
* Wait transactions to be mined.
*
* Based on https://raw.githubusercontent.com/Kaisle/await-transaction-mined/master/...
1
Given that you are using infura, you need to work with functions that use local private keys in web3py. See here for details
To sign a transaction locally you should use w3.eth.account.sign_transaction(transaction, key) your code will then be like this:
def send(web3, private_key, gas_price, transactionABI, value=0):
tx = {
'to': units_address,
...
1
I know it's too late to answer this question. But I hope it could help others.
You can not list transactions directly using web3 and JSON-RPC. In order to have a list of translations involving an address you need to scan Whole(or a part of) blocks of ethereum blockchain to find them.
You could guess! It's pretty time intensive!
To solve this problem you ...
0
I know this is a very late reply, but I am currently in the middle of reading this document so I will present my reasoning.
A smart contract can hold ether, tokens and/or other things of value which don't have to necessarily belong to the contract's owner. An escrow is a simple example of such a contract. If the owner loses the ability to manage the ...
0
I had implemented a solution based @Woodstock steps using SoftHSM and Graphene.
The source code is available in https://github.com/wshbair/HSM2ETH
Hope this will help
0
These would be steps
Take Uniswap ABI and construct web3.Contract objects based on it
Scan all AddLiquidity events from the block zero to the last mainnet block
Build your own database/list of deposits based on these
Here is some similar code to pick up all Transfer events for tokens:
def scan_chunk(self, start_block, end_block) -> Set[str]:
...
2
If a transaction receipt shows the to field empty and an address in the contractAddress field, does it mean that the specified contract was created?
Yes, it implies that a contract was deployed at the address specified in the contractAddress field. And the exact opposite implies that the transaction was sent to a contract which has already been deployed at ...
2
If the to field is empty it is most likely a transaction that deployed the smart contract, found in the contractAddress.
logs contain emitted events from Solidity. You can match them to actual ABI events using web3.py Contract API.
logs are optional. Smart contracts may not emit them and they are not present in account to account transfers.
Hope this ...
0
That's not directly possible without having A's private key. However there are other a bit more indirect ways:
1) A signs such a transaction in advance with his private key. He then sends the signed transaction to B (not via blockchain). If B wants to accept the transaction he broadcasts it to the blockchain. Or:
2) A middleman contract where A stores ...
0
At the moment Ropsten and Rinkeby use two different version of the ethereum protocol, for this reason the differences are normal. You may remember that on Ropsten it was tested the last fork various months ago (and they discovered the bug), while nobody did that on Rinkeby. As a matter of fact there are persisting differences.
2
After poking around blockscout per Ismael's suggestion, I found that the transaction I was looking for was available, so blockscout is definitely a viable option if you don't want to resort to iterating over all transactions.
However, I found that Etherscan provided the same information and I just completely missed it. For future readers, this curl got me ...
1
Etherscan gives you:
The ABI of the contract which this transaction was sent to here
The bytecode (aka input data) of the transaction here (under click to see more)
Taking these two pieces of information, you can run the following NodeJS script (web3 v1.2.1):
const Web3 = require("web3");
const ABI = [{"constant":false,"inputs":[{"name":"marketId","type":...
1
Here is the Transfer event prototype on each standard:
ERC20: event Transfer(address, address indexed _to, uint256 _value)
ERC721: event Transfer(address, address indexed _to, uint256 indexed _tokenId)
These two signatures are indeed the same when you hash them for the purpose of locating Transfer events in the ledger using (for example):
receipt.topics[0]...
0
It is not possible to transfer a token using the transfer() function unless you own the private key of the EOA that holds the tokens.
1
If a transaction with the same nonce has already been broadcast, then the others will be cleared from the tx pool.
This is a rule set by the clients that run nodes.
0
It seems that you need a good api for this operation. Last year, I used this site to search for wallets with good api.
Perhaps this information will help you, or maybe you have already resolved your problem;)
0
These are transactions that are called by a contract... Meaning, normally, a user calls a contract and the contract does something. In a normal situation, the contract gives you back tokens or ETH. In some contracts, the contract interacts with other contracts, meaning the contract called itself calls other contracts (this is an internal call). And sometimes ...
0
pure functions do consume gas if they are being called on-chain.
If you are calling the pure function off-chain (e.g. for the frontend of your website), there is no associated cost. If you are calling the pure function on-chain as a part of a transaction, it will consume gas.
Top 50 recent answers are included
