def i_am_alive(self, message):
if self.last_press_imalive:
delta = self.last_press_imalive - timezone.now()
if delta.days < 1 and delta.total_seconds(
) < LASTWILL_ALIVE_TIMEOUT:
take_off_blocking(self.contract.network.name,
address=self.contract.address)
tr = abi.ContractTranslator(self.eth_contract.abi)
par_int = ParInt(self.contract.network.name)
address = self.contract.network.deployaddress_set.all()[0].address
nonce = int(par_int.eth_getTransactionCount(address, "pending"), 16)
gas_limit = CONTRACT_GAS_LIMIT['LASTWILL_COMMON']
signed_data = sign_transaction(
address,
nonce,
gas_limit,
self.contract.network.name,
dest=self.eth_contract.address,
contract_data=binascii.hexlify(
tr.encode_function_call('imAvailable', [])).decode(),
)
self.eth_contract.tx_hash = par_int.eth_sendRawTransaction('0x' +
signed_data)
self.eth_contract.save()
self.last_press_imalive = timezone.now()
def mk_deposit_tx(self, value, valcode_addr):
casper_ct = abi.ContractTranslator(casper_utils.casper_abi)
deposit_func = casper_ct.encode('deposit',
[valcode_addr, self.coinbase])
deposit_tx = self.mk_transaction(self.chain.casper_address, value,
deposit_func)
return deposit_tx
def mk_prepare_tx(self, prepare_msg):
casper_ct = abi.ContractTranslator(casper_utils.casper_abi)
prepare_func = casper_ct.encode('prepare', [prepare_msg])
prepare_tx = self.mk_transaction(to=self.chain.casper_address,
value=0,
data=prepare_func)
return prepare_tx
def make_trustless_multisend(payouts, remainder, gasprice=20 * 10**9):
"""
Creates a transaction that trustlessly sends money to multiple recipients, and any
left over (unsendable) funds to the address specified in remainder.
Arguments:
payouts: A list of (address, value tuples)
remainder: An address in hex form to send any unsendable balance to
gasprice: The gas price, in wei
Returns: A transaction object that accomplishes the multisend.
"""
ct = abi.ContractTranslator(multisend_abi)
addresses = [utils.normalize_address(addr) for addr, value in payouts]
values = [value for addr, value in payouts]
cdata = ct.encode_constructor_arguments([addresses, values, utils.normalize_address(remainder)])
tx = transactions.Transaction(
0,
gasprice,
50000 + len(addresses) * 35000,
'',
sum(values),
multisend_contract + cdata)
tx.v = 27
tx.r = 0x0DA0DA0DA0DA0DA0DA0DA0DA0DA0DA0DA0DA0DA0DA0DA0DA0DA0DA0DA0DA0
tx.s = 0x0DA0DA0DA0DA0DA0DA0DA0DA0DA0DA0DA0DA0DA0DA0DA0DA0DA0DA0DA0DA0
while True:
try:
tx.sender
return tx
except Exception, e:
# Failed to generate public key
tx.r += 1
def ownershipTransferred(self, message):
address = NETWORKS[self.contract.network.name]['address']
if message['contractId'] != self.eth_contract_token.id:
if self.contract.state == 'WAITING_FOR_DEPLOYMENT':
take_off_blocking(self.contract.network.name)
print('ignored', flush=True)
return
if self.contract.state in ('ACTIVE', 'ENDED'):
take_off_blocking(self.contract.network.name)
return
if self.contract.state == 'WAITING_ACTIVATION':
self.contract.state = 'WAITING_FOR_DEPLOYMENT'
self.contract.save()
# continue deploy: call init
tr = abi.ContractTranslator(self.eth_contract_crowdsale.abi)
par_int = ParInt(self.contract.network.name)
nonce = int(par_int.eth_getTransactionCount(address, "pending"), 16)
gas_limit = 100000 + 80000 * self.contract.tokenholder_set.all().count(
)
print('nonce', nonce)
print('init message signed')
signed_data = sign_transaction(
address,
nonce,
gas_limit,
self.contract.network.name,
dest=self.eth_contract_crowdsale.address,
contract_data=binascii.hexlify(tr.encode_function_call(
'init', [])).decode())
self.eth_contract_crowdsale.tx_hash = par_int.eth_sendRawTransaction(
'0x' + signed_data)
self.eth_contract_crowdsale.save()
print('init message sended')
def check_contract(self):
print('checking', self.contract.name)
tr = abi.ContractTranslator(self.eth_contract.abi)
eth_int = EthereumProvider().get_provider(
network=self.contract.network.name)
address = self.contract.network.deployaddress_set.all()[0].address
nonce = int(eth_int.eth_getTransactionCount(address, "pending"), 16)
gas_price_current = self.get_gasstation_gasprice() or int(
1.1 * int(eth_int.eth_gasPrice(), 16))
gas_price_fixed = ETH_COMMON_GAS_PRICES[
self.contract.network.name] * NET_DECIMALS['ETH_GAS_PRICE']
gas_price = gas_price_current if gas_price_current < gas_price_fixed else gas_price_fixed
chain_id = int(eth_int.eth_chainId(), 16)
print('nonce', nonce)
signed_data = sign_transaction(
address,
nonce,
600000,
gas_price=gas_price,
chain_id=chain_id,
dest=self.eth_contract.address,
contract_data=binascii.hexlify(tr.encode_function_call(
'check', [])).decode(),
)
print('signed_data', signed_data)
eth_int.eth_sendRawTransaction(signed_data)
print('check ok!')
def deploy_target_contract(self, migration_contract, creator_idx=9):
owner = self.monitor(creator_idx)
t = abi.ContractTranslator(TARGET_ABI)
args = t.encode_constructor_arguments([migration_contract])
addr = self.state.evm(TARGET_INIT + args, sender=owner.key)
self.t = tester.ABIContract(self.state, TARGET_ABI, addr)
return addr, owner.gas()
def deploy_migration_contract(self, source_contract, creator_idx=9):
owner = self.monitor(creator_idx)
t = abi.ContractTranslator(MIGRATION_ABI)
args = t.encode_constructor_arguments([source_contract])
addr = self.state.evm(MIGRATION_INIT + args, sender=owner.key)
self.m = tester.ABIContract(self.state, MIGRATION_ABI, addr)
return addr, owner.gas()
def get_casper_ct():
import serpent
global _casper_ct
if not _casper_ct:
_casper_ct = abi.ContractTranslator(
serpent.mk_full_signature(open(casper_path).read()))
return _casper_ct
def deploy(self):
self.compile()
tr = abi.ContractTranslator(self.abi)
arguments = self.get_details().get_arguments()
par_int = ParInt()
nonce = int(par_int.parity_nextNonce(self.owner_address), 16)
print('nonce', nonce)
signed_data = json.loads(
requests.post(
'http://{}/sign/'.format(SIGNER),
json={
'source':
self.owner_address,
'data':
self.bytecode + binascii.hexlify(
tr.encode_constructor_arguments(arguments)).decode(),
'nonce':
nonce,
'gaslimit':
self.get_details().get_gaslimit(),
'value':
self.get_details().get_value(),
}).content.decode())['result']
print('signed_data', signed_data)
par_int.eth_sendRawTransaction('0x' + signed_data)
self.state = 'WAITING_FOR_DEPLOYMENT'
self.save()
def deploy_swap(self, provider, creator_idx=9):
owner = self.monitor(creator_idx)
t = abi.ContractTranslator(SWAP_ABI)
args = t.encode_constructor_arguments((provider, ))
addr = self.state.evm(SWAP_INIT + args, sender=owner.key)
self.s = tester.ABIContract(self.state, SWAP_ABI, addr)
return addr, owner.gas()
def setup_class(cls):
cls.s = tester.state()
cls.m = cls.s.abi_contract(cls.MARKET_CONTRACT, gas=cls.CONTRACT_GAS)
cls.heap_abi = abi.ContractTranslator(
mk_full_signature(cls.HEAP_CONTRACT))
cls.snapshot = cls.s.snapshot()
def deploy_wallet(self, _founder, creator_idx=9):
assert not hasattr(self, 'c')
owner = self.monitor(creator_idx)
t = abi.ContractTranslator(WALLET_ABI)
args = t.encode_constructor_arguments([])
addr = self.state.evm(WALLET_INIT + args, sender=owner.key)
self.wallet = tester.ABIContract(self.state, WALLET_ABI, addr)
return addr, owner.gas()
def __init__(self, address=ETHERPKI_DEFAULT_ADDRESS):
"""
Initialization of the event retriever.
address: the Ethereum address of the contract
"""
self.address = address
self._contracttranslator = abi.ContractTranslator(ETHERPKI_ABI)
def test_evm():
evm_code = serpent.compile(serpent_code)
translator = abi.ContractTranslator(
serpent.mk_full_signature(serpent_code))
data = translator.encode('main', [2, 5])
s = tester.state()
c = s.evm(evm_code)
o = translator.decode('main', s.send(tester.k0, c, 0, data))
assert o == [32]
def __deploy_contract(self, _bin, _abi, creator_idx, *args):
gas_before = self.state.block.gas_used
t = abi.ContractTranslator(_abi)
args = t.encode_constructor_arguments(args)
addr = self.state.evm(_bin + args, sender=tester.keys[creator_idx])
contract = tester.ABIContract(self.state, _abi, addr)
return contract, addr, self.state.block.gas_used - gas_before
def test_evm():
evm_code = serpent.compile(serpent_code)
translator = abi.ContractTranslator(
serpent.mk_full_signature(serpent_code))
data = translator.encode('main', [2, 5])
c = tester.Chain()
x = c.contract(evm_code, l='evm')
o = translator.decode('main', c.tx(tester.k0, x, 0, data))
assert o == [32]
def __deploy_wallet(self,
owner_key,
owners,
required=1,
daylimit=WALLET_DAY_LIMIT):
t = abi.ContractTranslator(WALLET_ABI)
args = t.encode_constructor_arguments((owners, required, daylimit))
addr = self.state.evm(WALLET_INIT + args, sender=owner_key)
return tester.ABIContract(self.state, WALLET_ABI, addr)
def __init__(self, address=TRUSTERY_DEFAULT_ADDRESS):
"""
Initialise events retriever.
address: the Ethereum Trustery contract address.
"""
self.address = address
# Initialise contract ABI.
self._contracttranslator = abi.ContractTranslator(TRUSTERY_ABI)
def deploy(self, eth_contract_attr_name='eth_contract'):
if self.contract.state not in ('CREATED', 'WAITING_FOR_DEPLOYMENT'):
print('launch message ignored because already deployed',
flush=True)
take_off_blocking(self.contract.network.name)
return
self.compile(eth_contract_attr_name)
eth_contract = getattr(self, eth_contract_attr_name)
tr = abi.ContractTranslator(eth_contract.abi)
arguments = self.get_arguments(eth_contract_attr_name)
print('arguments', arguments, flush=True)
eth_contract.constructor_arguments = binascii.hexlify(
tr.encode_constructor_arguments(
arguments)).decode() if arguments else ''
eth_int = EthereumProvider().get_provider(
network=self.contract.network.name)
address = NETWORKS[self.contract.network.name]['address']
nonce = int(eth_int.eth_getTransactionCount(address, "pending"), 16)
print('nonce', nonce, flush=True)
# print('BYTECODE', eth_contract.bytecode, flush=True)
# print('CONTRACT CODE', eth_contract.bytecode + binascii.hexlify(tr.encode_constructor_arguments(arguments)).decode() if arguments else '', flush=True)
data = eth_contract.bytecode + (binascii.hexlify(
tr.encode_constructor_arguments(arguments)).decode()
if arguments else '')
print('data =', data)
# if arguments:
# data = eth_contract.bytecode + (binascii.hexlify(
# tr.encode_constructor_arguments(arguments)
# ).decode())
# else:
# data = eth_contract.bytecode
print('DATA', data, flush=True)
gas_price = ETH_COMMON_GAS_PRICES[
self.contract.network.name] * NET_DECIMALS['ETH_GAS_PRICE']
signed_data = sign_transaction(address,
nonce,
self.get_gaslimit(),
self.contract.network.name,
value=self.get_value(),
contract_data=data,
gas_price=gas_price)
print('fields of transaction', flush=True)
print('source', address, flush=True)
print('gas limit', self.get_gaslimit(), flush=True)
print('value', self.get_value(), flush=True)
print('network', self.contract.network.name, flush=True)
print('signed_data', signed_data, flush=True)
eth_contract.tx_hash = eth_int.eth_sendRawTransaction('0x' +
signed_data)
eth_contract.save()
print('transaction sent', flush=True)
self.contract.state = 'WAITING_FOR_DEPLOYMENT'
self.contract.save()
def deploy_contract(self,
start,
end,
creator_idx=9,
migration_master=None):
founder = tester.accounts[creator_idx]
if migration_master is None:
migration_master = founder
t = abi.ContractTranslator(GNT_ABI)
args = t.encode_constructor_arguments(
(founder, migration_master, start, end))
addr = self.state.evm(GNT_INIT + args, sender=tester.keys[creator_idx])
return tester.ABIContract(self.state, GNT_ABI, addr), t
def msg_deployed(self, message):
print('msg_deployed method of the ico contract')
address = NETWORKS[self.contract.network.name]['address']
if self.contract.state != 'WAITING_FOR_DEPLOYMENT':
take_off_blocking(self.contract.network.name)
return
if self.reused_token:
self.contract.state = 'WAITING_ACTIVATION'
self.contract.save()
self.eth_contract_crowdsale.address = message['address']
self.eth_contract_crowdsale.save()
take_off_blocking(self.contract.network.name)
print('status changed to waiting activation')
return
if self.eth_contract_token.id == message['contractId']:
self.eth_contract_token.address = message['address']
self.eth_contract_token.save()
self.deploy(eth_contract_attr_name='eth_contract_crowdsale')
else:
self.eth_contract_crowdsale.address = message['address']
self.eth_contract_crowdsale.save()
tr = abi.ContractTranslator(self.eth_contract_token.abi)
eth_int = EthereumProvider().get_provider(
network=self.contract.network.name)
nonce = int(eth_int.eth_getTransactionCount(address, "pending"),
16)
chain_id = int(eth_int.eth_chainId(), 16)
gas_price_current = int(1.1 * int(eth_int.eth_gasPrice(), 16))
gas_price_fixed = ETH_COMMON_GAS_PRICES[
self.contract.network.name] * NET_DECIMALS['ETH_GAS_PRICE']
gas_price = gas_price_current if gas_price_current < gas_price_fixed else gas_price_fixed
print('nonce', nonce)
print('transferOwnership message signed')
signed_data = sign_transaction(
address,
nonce,
1000000,
dest=self.eth_contract_token.address,
contract_data=binascii.hexlify(
tr.encode_function_call(
'transferOwnership',
[self.eth_contract_crowdsale.address])).decode(),
gas_price=int(gas_price * 1.2),
chain_id=chain_id)
self.eth_contract_token.tx_hash = eth_int.eth_sendRawTransaction(
signed_data)
self.eth_contract_token.save()
print('transferOwnership message sended')
def deploy_contract(self,
founder,
start,
end,
creator_idx=9,
migration_master=None):
if migration_master is None:
migration_master = founder
owner = self.monitor(creator_idx)
t = abi.ContractTranslator(GNT_ABI)
args = t.encode_constructor_arguments(
(founder, migration_master, self.starting_block + start,
self.starting_block + end))
addr = self.state.evm(GNT_INIT + args, sender=owner.key)
self.c = tester.ABIContract(self.state, GNT_ABI, addr)
return addr, owner.gas()
def __init__(self, from_address=None, to_address=TRUSTERY_DEFAULT_ADDRESS):
"""
Initialise transactions.
from_address: the Ethereum address transactions should be sent from.
to_address: the Ethereum Trustery contract address.
"""
if from_address is None:
# Use the first Ethereum account address if no from address is specified.
self.from_address = ethclient.get_accounts()[0]
else:
self.from_address = from_address
self.to_address = to_address
# Initialise contract ABI.
self._contracttranslator = abi.ContractTranslator(TRUSTERY_ABI)
def __init__(self, from_address=None, to_address=ETHERPKI_DEFAULT_ADDRESS):
"""Initialize transactions.
from_address: the Ethereum address transactions should come from
to_address: the Ethereum EtherPKI contract address.
"""
if from_address is None:
# Uses the first Ethereum account address if none is specified.
self.from_address = ethclient.get_accounts()[0]
else:
self.from_address = from_address
self.to_address = to_address
# initialize contract ABI
self._contracttranslator = abi.ContractTranslator(ETHERPKI_ABI)
def __init__(self, sender, _abi, address, call_func, transact_func):
self._translator = abi.ContractTranslator(_abi)
self.abi = _abi
self.address = address = address20(address)
sender = address20(sender)
valid_kargs = set(('gasprice', 'startgas', 'value'))
class abi_method(object):
def __init__(this, f):
this.f = f
def transact(this, *args, **kargs):
assert set(kargs.keys()).issubset(valid_kargs)
data = self._translator.encode(this.f, args)
txhash = transact_func(sender=sender,
to=address,
value=kargs.pop('value', 0),
data=data,
**kargs)
return txhash
def call(this, *args, **kargs):
assert set(kargs.keys()).issubset(valid_kargs)
data = self._translator.encode(this.f, args)
res = call_func(sender=sender,
to=address,
value=kargs.pop('value', 0),
data=data,
**kargs)
if res:
res = self._translator.decode(this.f, res)
res = res[0] if len(res) == 1 else res
return res
def __call__(this, *args, **kargs):
if self._translator.function_data[this.f]['is_constant']:
return this.call(*args, **kargs)
else:
return this.transact(*args, **kargs)
for fname in self._translator.function_data:
func = abi_method(fname)
# create wrapper with signature
signature = self._translator.function_data[fname]['signature']
func.__doc__ = '%s(%s)' % (fname, ', '.join(
('%s %s' % x) for x in signature))
setattr(self, fname, func)
def check_contract(self):
print('checking', self.contract.name)
tr = abi.ContractTranslator(self.eth_contract.abi)
eth_int = EthereumProvider().get_provider(network=self.contract.network.name)
address = self.contract.network.deployaddress_set.all()[0].address
nonce = int(eth_int.eth_getTransactionCount(address, "pending"), 16)
print('nonce', nonce)
signed_data = sign_transaction(
address, nonce, 600000, self.contract.network.name,
dest=self.eth_contract.address,
contract_data=binascii.hexlify(
tr.encode_function_call('check', [])
).decode(),
)
print('signed_data', signed_data)
eth_int.eth_sendRawTransaction('0x' + signed_data)
print('check ok!')
def freeze_wish(amount):
abi_dict = get_freeze_wish_abi()
tr = abi.ContractTranslator(abi_dict)
par_int = ParInt(NETWORK_SIGN_TRANSACTION_WISH)
nonce = int(
par_int.eth_getTransactionCount(UPDATE_WISH_ADDRESS, "pending"), 16)
signed_data = sign_transaction(
UPDATE_WISH_ADDRESS,
nonce,
100000,
NETWORK_SIGN_TRANSACTION_WISH,
dest=MYWISH_ADDRESS,
contract_data=binascii.hexlify(
tr.encode_function_call(
'transfer', [COLD_WISH_ADDRESS, int(amount)])).decode())
tx_hash = par_int.eth_sendRawTransaction('0x' + signed_data)
print('tx_hash=', tx_hash, flush=True)
def cancel(self, message):
tr = abi.ContractTranslator(self.eth_contract.abi)
eth_int = EthereumProvider().get_provider(network=self.contract.network.name)
address = self.contract.network.deployaddress_set.all()[0].address
nonce = int(eth_int.eth_getTransactionCount(address, "pending"), 16)
gas_limit = CONTRACT_GAS_LIMIT['LASTWILL_COMMON']
signed_data = sign_transaction(
address, nonce, gas_limit, self.contract.network.name,
dest=self.eth_contract.address,
contract_data=binascii.hexlify(
tr.encode_function_call('kill', [])
).decode(),
)
self.eth_contract.tx_hash = eth_int.eth_sendRawTransaction(
'0x' + signed_data
)
self.eth_contract.save()
def __init__(self, client, privkey, faucet=False):
self.__client = client
self.__privkey = privkey
self.__eth_balance = None
self.__gnt_balance = None
self.__gnt_reserved = 0
self._awaiting = [] # Awaiting individual payments
self._inprogress = {} # Sent transactions.
self.__last_sync_check = time.time()
self.__sync = False
self.__temp_sync = False
self.__faucet = faucet
self.__testGNT = abi.ContractTranslator(TestGNT.ABI)
self._waiting_for_faucet = False
self.deadline = sys.maxsize
self.load_from_db()
super(PaymentProcessor, self).__init__(13)
