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)