def createOrder(self, side, expires, price, amount, token, userAccount, user_wallet_private_key, randomseed = None):
global addressRyxEx, web3
print("\nCreating '" + side + "' order for %.18f tokens @ %.18f ETH/token" % (amount, price))
# Validate the input
if len(user_wallet_private_key) != 64: raise ValueError('WARNING: user_wallet_private_key must be a hexadecimal string of 64 characters long')
# Ensure good parameters
token = Web3.toChecksumAddress(token)
userAccount = Web3.toChecksumAddress(userAccount)
user_wallet_private_key = Web3.toBytes(hexstr=user_wallet_private_key)
# Build the order parameters
amountBigNum = amount
amountBaseBigNum = float(amount) * float(price)
if randomseed != None: random.seed(randomseed) # Seed the random number generator for unit testable results
orderNonce = random.randint(0,10000000000)
if side == 'sell':
tokenGive = token
tokenGet = '0x0000000000000000000000000000000000000000'
amountGet = web3.toWei(amountBaseBigNum, 'ether')
amountGive = web3.toWei(amountBigNum, 'ether')
elif side == 'buy':
tokenGive = '0x0000000000000000000000000000000000000000'
tokenGet = token
amountGet = web3.toWei(amountBigNum, 'ether')
amountGive = web3.toWei(amountBaseBigNum, 'ether')
else:
print("WARNING: invalid order side, no action taken: " + str(side))
# Serialize (according to ABI) and sha256 hash the order's parameters
hashhex = self.soliditySha256(
['address', 'address', 'uint256', 'address', 'uint256', 'uint256', 'uint256'],
[addressRyxEx, tokenGet, amountGet, tokenGive, amountGive, expires, orderNonce]
)
# Sign the hash of the order's parameters with our private key (this also addes the "Ethereum Signed Message" header)
signresult = web3.eth.account.sign(message_hexstr=hashhex, private_key=user_wallet_private_key)
#print("Result of sign:" + str(signresult))
orderDict = {
'amountGet' : amountGet,
'amountGive' : amountGive,
'tokenGet' : tokenGet,
'tokenGive' : tokenGive,
'contractAddr' : addressRyxEx,
'expires' : expires,
'nonce' : orderNonce,
'user' : userAccount,
'v' : signresult['v'],
'r' : signresult['r'].hex(),
's' : signresult['s'].hex(),
}
return orderDict
def list_sire(self, kitty_id, start_amt, end_amt, duration, **kwargs):
"""Lists a cat to sire."""
cats_contract = get_cats_contract('core')
contract_args = kwargs
contract_args.update({'from': self.addr})
return cats_contract.transact(contract_args).createSiringAuction(
kitty_id,
web3.toWei(start_amt, 'ether'),
web3.toWei(end_amt, 'ether'),
duration,
)
def withdraw_eth(username, amount, address):
user_balance = table.get_item(
Key={'UserIDandSymbol': '{username}.ETH'.format(
username=username)})['Item']
account = session.query(Account).filter(
Account.username == username).first()
hotwallet = session.query(Account).filter(
Account.username == 'hotwallet').first()
gasprice = web3.toWei(10, 'Gwei')
startgas = 21000
print('user balance', user_balance['Balance'])
print('amount', amount, 'withdraw fee',
web3.fromWei(gasprice * startgas, values.eth_base_unit))
if amount == 'all':
amount = user_balance['Balance']
if amount <= 0:
return {
'success': False,
'error': 'You can not withdraw 0 or a negative amount'
}
if amount > user_balance['Balance']:
return {
'success': False,
'error': 'You can not withdraw more than your available balance'
}
if web3.toWei(amount, values.eth_base_unit) <= gasprice * startgas:
return {
'success': False,
'error': 'You can not withdraw less than the withdrawal fee'
}
tx = Transaction(
nonce=web3.eth.getTransactionCount(hotwallet.public_key),
gasprice=gasprice,
startgas=startgas,
to=address,
value=web3.toWei(amount, eth_base_unit) - gasprice * startgas,
data=b'',
)
tx.sign(bytes(private_key))
raw_tx = rlp.encode(tx)
raw_tx_hex = web3.toHex(raw_tx)
tx_id = web3.eth.sendRawTransaction(raw_tx_hex)
table.update_item(
Key={'UserIDandSymbol': '{username}.ETH'.format(username=username)},
UpdateExpression='SET Balance = Balance - :val1',
ExpressionAttributeValues={':val1': amount})
return {'success': True, 'error': None, 'tx_id': tx_id}
print('Withdrew {amount} from {user} to address {address}'.format(
amount=amount, user=username, address=address))
def node2(id,data):
ganache_url="http://127.0.0.1:7545"
web3=Web3(Web3.HTTPProvider(ganache_url))
node2_address="0xe8652965ed04Bce6C9764e7eA80a26e61b434f8F"
node2_pk="b28fc4327c99022b087d79e8edadada2e2d71d029d3552d4700bf78b7a3968f2"
fp = open('abi.json', 'r')
abi=json.load(fp)
contract_address=web3.toChecksumAddress("0xbd12Ef3a93b06a72374188017Ef67b9FD8f6717e")
contract=web3.eth.contract(address=contract_address,abi=abi)
nonce=web3.eth.getTransactionCount(node2_address)
# print("CMP! ADD TO BLOCKCHAIN id", id, "data", data, "readable", data.hex())
transaction=contract.functions.addData(id,data).buildTransaction({
'gas':70000,
'gasPrice':web3.toWei('1','gwei'),
'from': node2_address,
'nonce': nonce
})
signed_transaction=web3.eth.account.signTransaction(transaction, node2_pk)
transaction_hash=web3.eth.sendRawTransaction(signed_transaction.rawTransaction)
return web3.toHex(transaction_hash)
def prepare_paxos_dollar_tx(to_address, private_key, amount_to_send):
contract = load_contract('0x8e870d67f660d95d5be530380d0ec0bd388289e1')
#checksum addresses, just to be sure
to_address = w3.toChecksumAddress(to_address)
#grab nonce
from_address = w3.toChecksumAddress(
str(w3.eth.account.privateKeyToAccount(private_key).address))
nonce = w3.eth.getTransactionCount(from_address)
balance = w3.eth.getBalance(from_address)
print(balance)
#prepare transaction for transfer function
#for now, gas limit is 1,000,000 and gas price is 3 Gwei
amount = int(amount_to_send * 4485035922634800)
print(amount)
new_txn = {
'to': to_address,
'value': w3.toHex(amount),
'gas': 21000,
'gasPrice': w3.toWei('15', 'gwei'),
'nonce': nonce,
'chainId': 1
}
#sign transaction
signed_txn = w3.eth.account.signTransaction(new_txn,
private_key=private_key)
#return signed transaction
return (signed_txn)
print(private_key)
def list_kitty(self, kitty_id, start_amt, end_amt, duration, **kwargs):
"""Lists the cat with id `kitty_id` for sale on the
exchange for `amt`.
If you do not own the cat with that id, raises
`KittyNotOwnedException`.
"""
cats_contract = get_cats_contract('core')
contract_args = kwargs
contract_args.update({'from': self.addr})
return cats_contract.transact(contract_args).createSaleAuction(
kitty_id,
web3.toWei(start_amt, 'ether'),
web3.toWei(end_amt, 'ether'),
duration,
)
def trade(self, order, eth_amount, user_private_key):
"""
Invokes on-chain trade
:param order: order
:type order: object
:param eth_amount: ETH amount
:type eth_amount: float
:param user_private_key: user private key
:type user_private_key: string
:return: tx
:rtype: object
"""
global web3, addressEtherDelta
userAccount = w3.eth.account.privateKeyToAccount(user_private_key).address
# Transaction info
maxGas = 250000
gasPriceWei = 1000000000 # 1 Gwei
if order['tokenGive'] == '0x0000000000000000000000000000000000000000':
ordertype = 'buy' # it's a buy order so we are selling tokens for ETH
amount = eth_amount / float(order['price'])
else:
ordertype = 'sell' # it's a sell order so we are buying tokens for ETH
amount = eth_amount
amount_in_wei = web3.toWei(amount, 'ether')
#print("\nTrading " + str(eth_amount) + " ETH of tokens (" + str(amount) + " tokens) against this " + ordertype + " order: %.10f tokens @ %.10f ETH/token" % (float(order['ethAvailableVolume']), float(order['price'])))
#print("Details about order: " + str(order))
# trade function arguments
kwargs = {
'tokenGet' : Web3.toChecksumAddress(order['tokenGet']),
'amountGet' : int(Decimal(order['amountGet'])),
'tokenGive' : Web3.toChecksumAddress(order['tokenGive']),
'amountGive' : int(Decimal(order['amountGive'])),
'expires' : int(order['expires']),
'nonce' : int(order['nonce']),
'user' : Web3.toChecksumAddress(order['user']),
'v' : order['v'],
'r' : w3.toBytes(hexstr=order['r']),
's' : w3.toBytes(hexstr=order['s']),
'amount' : int(amount_in_wei),
}
# Bail if there's no private key
if len(user_private_key) != 64: raise ValueError('WARNING: user_private_key must be a hexadecimal string of 64 characters long')
# Build binary representation of the function call with arguments
abidata = self.contractEtherDelta.encodeABI('trade', kwargs=kwargs)
#print("abidata: " + str(abidata))
nonce = w3.eth.getTransactionCount(userAccount)
# Override to have same as other transaction:
#nonce = 53
#print("nonce: " + str(nonce))
transaction = { 'to': addressEtherDelta, 'from': userAccount, 'gas': maxGas, 'gasPrice': gasPriceWei, 'data': abidata, 'nonce': nonce, 'chainId': 1}
#print(transaction)
signed = w3.eth.account.signTransaction(transaction, user_private_key)
#print("signed: " + str(signed))
result = w3.eth.sendRawTransaction(w3.toHex(signed.rawTransaction))
#print("Transaction returned: " + str(result))
#print("\nDone! You should see the transaction show up at https://etherscan.io/tx/" + w3.toHex(result))
return result
def give_birth(self, kitty_id, amt, **kwargs):
"""Makes your kitty give birth."""
cats_contract = get_cats_contract('core')
contract_args = kwargs
contract_args.update({'from': self.addr})
contract_args.update('value': web3.toWei(amt, 'ether'))
return cats_contract.transact(contract_args).giveBirth(
kitty_id,
)
def get_tx(contract):
nonce = web3.eth.getTransactionCount(dev)
tx = {
'nonce': nonce,
'to': contract,
'value': 0,
'gas': 2000000,
'gasPrice': web3.toWei('50', 'gwei')
}
return tx
def purchase_sire(self, kitty_id, sire_id, amt, **kwargs):
"""Makes your cat f**k the other cat."""
cats_contract = get_cats_contract('core')
contract_args = kwargs
contract_args.update({'from': self.addr})
contract_args.update({'value': web3.toWei(amt, 'ether')})
return cats_contract.transact(contract_args).bidOnSiringAuction(
sire_id,
kitty_id,
)
def send_to_hot_wallet(public_key):
account = session.query(EthereumAccount).filter(
EthereumAccount.public_key == public_key).one()
hotwallet = session.query(EthereumAccount).filter(
EthereumAccount.username == 'hotwallet').first()
gasprice = web3.toWei(1, 'Gwei')
startgas = 21000
tx = Transaction(
nonce=web3.eth.getTransactionCount(account.public_key),
gasprice=gasprice,
startgas=startgas,
to=hotwallet.public_key,
value=web3.toWei(account.balance, values.eth_base_unit) -
gasprice * startgas,
data=b'',
)
tx.sign(bytes(ord(x) for x in account.private_key))
raw_tx = rlp.encode(tx)
raw_tx_hex = web3.toHex(raw_tx)
web3.eth.sendRawTransaction(raw_tx_hex)
def add_coin(purchase_add, amount):
'''
account purchase crowdcoin
'''
amount = int(amount)
if infura_url != "http://127.0.0.1:7545":
amount = web3.toWei(amount, 'ether')
tx = get_tx(reward.address)
tx['data'] = reward.encodeABI(fn_name='purchase_coin',
args=[purchase_add, amount])
return sign_tx(tx)
def trade(order, etherAmount):
global user_wallet_private_key, web3, addressEtherDelta, contractEtherDelta
print("\nTrading " + str(etherAmount) +
" ETH of tokens against this order: %.10f tokens @ %.10f ETH/token" %
(float(order['ethAvailableVolume']), float(order['price'])))
print("Details about order: " + str(order))
# Transaction info
amount_to_buyWei = web3.toWei(etherAmount, 'ether')
maxGas = 250000
gasPriceWei = 5000000000 # 1 Gwei
# trade function arguments
kwargs = {
'tokenGet': Web3.toChecksumAddress(order['tokenGet']),
'amountGet': int(float(order['amountGet'])),
'tokenGive': Web3.toChecksumAddress(order['tokenGive']),
'amountGive': int(float(order['amountGive'])),
'expires': int(order['expires']),
'nonce': int(order['nonce']),
'user': Web3.toChecksumAddress(order['user']),
'v': order['v'],
'r': web3.toBytes(hexstr=order['r']),
's': web3.toBytes(hexstr=order['s']),
'amount': int(amount_to_buyWei),
}
# Build binary representation of the function call with arguments
abidata = contractEtherDelta.encodeABI('trade', kwargs=kwargs)
nonce = web3.eth.getTransactionCount(userAccount)
transaction = {
'to': addressEtherDelta,
'from': userAccount,
'gas': 250000,
'gasPrice': 100000000,
'data': abidata,
'nonce': nonce,
'chainId': 1
}
if len(user_wallet_private_key) == 64:
signed = web3.eth.account.signTransaction(transaction,
user_wallet_private_key)
result = web3.eth.sendRawTransaction(web3.toHex(signed.rawTransaction))
print("Transaction returned: " + str(result))
print(
"\nDone! You should see the transaction show up at https://etherscan.io/tx/"
+ web3.toHex(result))
else:
print(
"WARNING: no valid private key found, user_wallet_private_key must be 64 characters long"
)
ws.close()
def buy_kitty(self, kitty_id, amt, **kwargs):
"""Tries to purchase the cat with id `kitty_id` by
sending `amt` ether to the CryptoKittiesSaleAuction
contract address.
If you do not have enough ethereum, raises
`InsufficientFundsException`.
"""
cats_contract = get_cats_contract('sale')
contract_args = kwargs
contract_args.update({'from': self.addr})
contract_args.update({'value': web3.toWei(amt, 'ether')})
return cats_contract.transact(contract_args).bid(kitty_id)
def send_eth(self, address, amt, data=None, **kwargs):
"""Sends `amt` ethereum to `address` with the `data`
field attached to it.
If you do not have enough ethereum, raises
`InsufficientFundsException`.
"""
transaction = {
'from': self.addr,
'to': address,
'value': web3.toWei(amt, 'ether'),
'data': data,
}
transaction.update(kwargs)
return web3.eth.sendTransaction(transaction)
def send_eth(amount, addressto, addressfrom, secret):
amt = web3.toWei(amount, 'ether')
to = w3.toChecksumAddress(addressto)
frm = w3.toChecksumAddress(addressfrom)
gasprice = w3.eth.gasPrice
gas = w3.eth.estimateGas({'to': to, 'from': frm})
transaction = {
'to': addressto,
'value': amt,
'gas': gas,
'gasPrice': gasprice,
'nonce': w3.eth.getTransactionCount(frm),
'chainId': 1
}
signedtxn = w3.eth.account.signTransaction(transaction, private_key=secret)
w3.eth.sendRawTransaction(signedtxn.rawTtansaction)
return w3.eth.waitForTransactionReceipt(signedtxn.hash, timeout=1200)
def node3(id,data):
ganache_url="http://127.0.0.1:7545"
web3=Web3(Web3.HTTPProvider(ganache_url))
node3_address="0x4eD6E3e8102A2cE2924EabF5f9916BB3bD6B66d5"
node3_pk="4058bc0213a462b74deb3bfc42eba9d35e6e0e15debbbc92fcfebe414fae6058"
fp = open('abi.json', 'r')
abi=json.load(fp)
contract_address=web3.toChecksumAddress("0xbd12Ef3a93b06a72374188017Ef67b9FD8f6717e")
contract=web3.eth.contract(address=contract_address,abi=abi)
nonce=web3.eth.getTransactionCount(node3_address)
transaction=contract.functions.addData(id,data).buildTransaction({
'gas':70000,
'gasPrice':web3.toWei('1','gwei'),
'from': node3_address,
'nonce': nonce
})
signed_transaction=web3.eth.account.signTransaction(transaction, node3_pk)
transaction_hash=web3.eth.sendRawTransaction(signed_transaction.rawTransaction)
return web3.toHex(transaction_hash)
def node1(id,data):
ganache_url="http://127.0.0.1:7545"
web3=Web3(Web3.HTTPProvider(ganache_url))
node1_address="0xf49437Dd2E96f1249815c82727Cc17c8388d9349"
node1_pk="22aaa185ee18e1b169fa7192d6428fcfc4db2f0386dffb1eee100c2cfdf94bd5"
fp = open('abi.json', 'r')
abi=json.load(fp)
contract_address=web3.toChecksumAddress("0xbd12Ef3a93b06a72374188017Ef67b9FD8f6717e")
contract=web3.eth.contract(address=contract_address,abi=abi)
nonce=web3.eth.getTransactionCount(node1_address)
transaction=contract.functions.addData(id,data).buildTransaction({
'gas':70000,
'gasPrice':web3.toWei('1','gwei'),
'from': node1_address,
'nonce': nonce
})
signed_transaction=web3.eth.account.signTransaction(transaction, node1_pk)
transaction_hash=web3.eth.sendRawTransaction(signed_transaction.rawTransaction)
return web3.toHex(transaction_hash)
def fixed_strategy(web3, params):
return web3.toWei(strategy_or_price_in_gwei, "gwei")
#from web3.providers.rpc import HTTPProvider
#web3 = Web3(HTTPProvider('"http://localhost:8545"'))
web3 = Web3(KeepAliveRPCProvider(host='localhost', port='8545'))
print('Connected')
fromAddress = web3.personal.listAccounts[1]
toAddress = web3.personal.listAccounts[0]
#txn='{from: fromAddress,to: toAddress, value: web3.toWei(2,"ether")}'
bl = web3.fromWei(web3.eth.getBalance(fromAddress), "ether")
from getpass import getpass
pw = getpass(prompt='Enter the password for the sender: ')
web3.personal.unlockAccount(fromAddress, pw)
params = {}
params['to'] = toAddress
params['from'] = fromAddress
params['data'] = web3.toHex("testan")
params['value'] = web3.toWei(2, "ether")
tx_hash = web3.eth.sendTransaction(params)
tobal = web3.fromWei(web3.eth.getBalance(toAddress), "ether")
ac = web3.eth.accounts
print(ac)
print(bl)
print(tobal)
print(tx_hash)
