def test_submission_prepended_with_con_succeeds(self): w = Wallet() expected_processor = secrets.token_bytes(32) balances_key = '{}{}{}{}{}'.format('currency', config.INDEX_SEPARATOR, 'balances', config.DELIMITER, w.verifying_key().hex()) self.nonce_manager.set(balances_key, 500000) tx = TransactionBuilder(w.verifying_key(), contract='submission', function='submit_contract', kwargs={'name': 'con_bad_name', 'code': 'blah'}, stamps=3000, processor=expected_processor, nonce=0) tx.sign(w.signing_key()) tx_bytes = tx.serialize() tx_struct = transaction_capnp.NewTransaction.from_bytes_packed(tx_bytes) transaction_is_valid(tx=tx_struct, expected_processor=expected_processor, driver=self.nonce_manager)
def test_all_valid_with_stamps_when_balance_is_set(self): w = Wallet() expected_processor = secrets.token_bytes(32) tx = TransactionBuilder(w.verifying_key(), contract='currency', function='transfer', kwargs={'amount': 10, 'to': 'jeff'}, stamps=500000, processor=expected_processor, nonce=0) tx.sign(w.signing_key()) tx_bytes = tx.serialize() tx_struct = transaction_capnp.NewTransaction.from_bytes_packed(tx_bytes) balances_key = '{}{}{}{}{}'.format('currency', config.INDEX_SEPARATOR, 'balances', config.DELIMITER, tx.payload.sender.hex()) self.nonce_manager.set(balances_key, 500000) transaction_is_valid(tx=tx_struct, expected_processor=expected_processor, driver=self.nonce_manager) balance = self.nonce_manager.get(balances_key) or 0 self.assertEqual(balance, 500000)
def test_sending_transfer_of_most_money_doesnt_fail_if_enough_stamps(self): self.nonce_manager.set_var('stamp_cost', 'S', ['value'], value=3000) w = Wallet() expected_processor = secrets.token_bytes(32) balances_key = '{}{}{}{}{}'.format('currency', config.INDEX_SEPARATOR, 'balances', config.DELIMITER, w.verifying_key().hex()) self.nonce_manager.set(balances_key, 500000) tx = TransactionBuilder(w.verifying_key(), contract='currency', function='transfer', kwargs={'amount': 499990, 'to': 'jeff'}, stamps=3000, processor=expected_processor, nonce=0) tx.sign(w.signing_key()) tx_bytes = tx.serialize() tx_struct = transaction_capnp.NewTransaction.from_bytes_packed(tx_bytes) transaction_is_valid(tx=tx_struct, expected_processor=expected_processor, driver=self.nonce_manager)
def test_nonce_minus_pending_nonce_equal_tx_per_block_fails(self): w = Wallet() expected_processor = secrets.token_bytes(32) balances_key = '{}{}{}{}{}'.format('currency', config.INDEX_SEPARATOR, 'balances', config.DELIMITER, w.verifying_key().hex()) self.nonce_manager.set(balances_key, 500000) self.nonce_manager.set_nonce(processor=expected_processor, sender=w.verifying_key(), nonce=1) self.nonce_manager.set_pending_nonce(processor=expected_processor, sender=w.verifying_key(), nonce=16) tx = TransactionBuilder(w.verifying_key(), contract='currency', function='transfer', kwargs={'amount': 10, 'to': 'jeff'}, stamps=500000, processor=expected_processor, nonce=16) tx.sign(w.signing_key()) tx_bytes = tx.serialize() tx_struct = transaction_capnp.NewTransaction.from_bytes_packed(tx_bytes) with self.assertRaises(transaction.TransactionTooManyPendingException): transaction_is_valid(tx=tx_struct, expected_processor=expected_processor, driver=self.nonce_manager)
def test_processor_and_nonce_correct_but_not_enough_stamps_returns_false(self): w = Wallet() expected_processor = secrets.token_bytes(32) tx = TransactionBuilder(w.verifying_key(), contract='currency', function='transfer', kwargs={'amount': 10, 'to': 'jeff'}, stamps=500000, processor=expected_processor, nonce=0) tx.sign(w.signing_key()) tx_bytes = tx.serialize() tx_struct = transaction_capnp.NewTransaction.from_bytes_packed(tx_bytes) with self.assertRaises(transaction.TransactionSenderTooFewStamps): transaction_is_valid(tx=tx_struct, expected_processor=expected_processor, driver=self.nonce_manager) balances_key = '{}{}{}{}{}'.format('currency', config.INDEX_SEPARATOR, 'balances', config.DELIMITER, tx.payload.sender.hex()) balance = self.nonce_manager.get(balances_key) or 0 self.assertEqual(balance, 0)
def test_processor_is_expected_but_nonce_is_incorrect_returns_false(self): w = Wallet() expected_processor = secrets.token_bytes(32) tx = TransactionBuilder(w.verifying_key(), contract='currency', function='transfer', kwargs={'amount': 10, 'to': 'jeff'}, stamps=500000, processor=expected_processor, nonce=1) tx.sign(w.signing_key()) tx_bytes = tx.serialize() tx_struct = transaction_capnp.NewTransaction.from_bytes_packed(tx_bytes) with self.assertRaises(transaction.TransactionNonceInvalid): transaction_is_valid(tx=tx_struct, expected_processor=expected_processor, driver=self.nonce_manager)
def test_non_strict_fails_if_same_nonce(self): w = Wallet() expected_processor = secrets.token_bytes(32) balances_key = '{}{}{}{}{}'.format('currency', config.INDEX_SEPARATOR, 'balances', config.DELIMITER, w.verifying_key().hex()) self.nonce_manager.set(balances_key, 500000) tx = TransactionBuilder(w.verifying_key(), contract='currency', function='transfer', kwargs={'amount': 10, 'to': 'jeff'}, stamps=500000, processor=expected_processor, nonce=0) tx.sign(w.signing_key()) tx_bytes = tx.serialize() tx_struct = transaction_capnp.NewTransaction.from_bytes_packed(tx_bytes) transaction_is_valid(tx=tx_struct, expected_processor=expected_processor, driver=self.nonce_manager, strict=False) tx = TransactionBuilder(w.verifying_key(), contract='currency', function='transfer', kwargs={'amount': 10, 'to': 'jeff'}, stamps=500000, processor=expected_processor, nonce=0) tx.sign(w.signing_key()) tx_bytes = tx.serialize() tx_struct = transaction_capnp.NewTransaction.from_bytes_packed(tx_bytes) with self.assertRaises(transaction.TransactionNonceInvalid): transaction_is_valid(tx=tx_struct, expected_processor=expected_processor, driver=self.nonce_manager, strict=False)
def test_processor_and_nonce_correct_increments_pending_nonce_by_one(self): w = Wallet() expected_processor = secrets.token_bytes(32) tx = TransactionBuilder(w.verifying_key(), contract='currency', function='transfer', kwargs={'amount': 10, 'to': 'jeff'}, stamps=10000, processor=expected_processor, nonce=0) tx.sign(w.signing_key()) tx_bytes = tx.serialize() tx_struct = transaction_capnp.NewTransaction.from_bytes_packed(tx_bytes) transaction_is_valid(tx=tx_struct, expected_processor=expected_processor, driver=self.nonce_manager) pending_nonce = self.nonce_manager.get_pending_nonce(expected_processor, w.verifying_key()) self.assertEqual(pending_nonce, 1)
def process_transaction(tx: transaction_capnp.Transaction): # Deserialize? try: transaction_is_valid(tx=tx, expected_processor=conf.HOST_VK, driver=driver, strict=True) except TransactionNonceInvalid: return {'error': 'Transaction nonce is invalid.'} except TransactionProcessorInvalid: return { 'error': 'Transaction processor does not match expected processor.' } except TransactionTooManyPendingException: return { 'error': 'Too many pending transactions currently in the block.' } except TransactionSenderTooFewStamps: return { 'error': 'Transaction sender has too few stamps for this transaction.' } except TransactionPOWProofInvalid: return {'error': 'Transaction proof of work is invalid.'} except TransactionSignatureInvalid: return {'error': 'Transaction is not signed by the sender.'} except TransactionStampsNegative: return {'error': 'Transaction has negative stamps supplied.'} # Pass protocol level variables into environment so they are accessible at runtime in smart contracts block_hash = driver.latest_block_hash block_num = driver.latest_block_num dt = datetime.utcfromtimestamp(tx.metadata.timestamp) dt_object = Datetime(year=dt.year, month=dt.month, day=dt.day, hour=dt.hour, minute=dt.minute, second=dt.second, microsecond=dt.microsecond) environment = { 'block_hash': block_hash, 'block_num': block_num, 'now': dt_object } tx_output = execution.execute_tx(executor=client.executor, transaction=tx, environment=environment) client.executor.driver.commit() store_block(tx, block_hash, block_num) driver.commit_nonces() driver.delete_pending_nonces() tx_dict = tx_output.to_dict() state_changes = {} for item in tx_dict['state']: state_changes[item['key'].decode("utf-8")] = item['value'].decode( "utf-8") results = { 'state_changes': state_changes, 'status_code': tx_output.status, 'stamps_used': tx_output.stampsUsed } return results
def test_multiple_nonces_in_sequence_all_verify(self): w = Wallet() expected_processor = secrets.token_bytes(32) balances_key = '{}{}{}{}{}'.format('currency', config.INDEX_SEPARATOR, 'balances', config.DELIMITER, w.verifying_key().hex()) self.nonce_manager.set(balances_key, 500000) tx = TransactionBuilder(w.verifying_key(), contract='currency', function='transfer', kwargs={'amount': 10, 'to': 'jeff'}, stamps=500000, processor=expected_processor, nonce=0) tx.sign(w.signing_key()) tx_bytes = tx.serialize() tx_struct = transaction_capnp.NewTransaction.from_bytes_packed(tx_bytes) transaction_is_valid(tx=tx_struct, expected_processor=expected_processor, driver=self.nonce_manager) tx = TransactionBuilder(w.verifying_key(), contract='currency', function='transfer', kwargs={'amount': 10, 'to': 'jeff'}, stamps=500000, processor=expected_processor, nonce=1) tx.sign(w.signing_key()) tx_bytes = tx.serialize() tx_struct = transaction_capnp.NewTransaction.from_bytes_packed(tx_bytes) transaction_is_valid(tx=tx_struct, expected_processor=expected_processor, driver=self.nonce_manager) tx = TransactionBuilder(w.verifying_key(), contract='currency', function='transfer', kwargs={'amount': 10, 'to': 'jeff'}, stamps=500000, processor=expected_processor, nonce=2) tx.sign(w.signing_key()) tx_bytes = tx.serialize() tx_struct = transaction_capnp.NewTransaction.from_bytes_packed(tx_bytes) transaction_is_valid(tx=tx_struct, expected_processor=expected_processor, driver=self.nonce_manager) tx = TransactionBuilder(w.verifying_key(), contract='currency', function='transfer', kwargs={'amount': 10, 'to': 'jeff'}, stamps=500000, processor=expected_processor, nonce=3) tx.sign(w.signing_key()) tx_bytes = tx.serialize() tx_struct = transaction_capnp.NewTransaction.from_bytes_packed(tx_bytes) transaction_is_valid(tx=tx_struct, expected_processor=expected_processor, driver=self.nonce_manager)
async def submit_transaction(self, request): log.info(f'Got req:{request}') if len(self.queue) >= self.max_queue_len: return response.json({'error': "Queue full. Resubmit shortly."}, status=503) # Try to deserialize transaction. try: tx = transaction_capnp.NewTransaction.from_bytes_packed( request.body) except Exception as e: return response.json({'error': 'Malformed transaction.'.format(e)}, status=400) error = False msg = {'error': 'Unknown Error'} try: transaction_is_valid( tx=tx, expected_processor=self.wallet.verifying_key(), driver=self.driver, strict=True) # These exceptions are tested to work in the transaction_is_valid tests except TransactionNonceInvalid: msg = {'error': 'Transaction nonce is invalid.'} error = True except TransactionProcessorInvalid: msg = { 'error': 'Transaction processor does not match expected processor.' } error = True except TransactionTooManyPendingException: msg = { 'error': 'Too many pending transactions currently in the block.' } error = True except TransactionSenderTooFewStamps: msg = { 'error': 'Transaction sender has too few stamps for this transaction.' } error = True except TransactionPOWProofInvalid: msg = {'error': 'Transaction proof of work is invalid.'} error = True except TransactionSignatureInvalid: msg = {'error': 'Transaction is not signed by the sender.'} error = True except TransactionStampsNegative: msg = {'error': 'Transaction has negative stamps supplied.'} error = True if error: log.error(msg) return response.json(msg) # Put it in the rate limiter queue. log.info('Q TIME') self.queue.append(tx) tx_hash = tx_hash_from_tx(tx) return response.json({ 'success': 'Transaction successfully submitted to the network.', 'hash': tx_hash.hex() })