def transaction_is_valid(tx: transaction_capnp.Transaction,
expected_processor: bytes,
driver: BlockchainDriver,
strict=True,
tx_per_block=15):
# Validate Signature
if not wallet._verify(tx.payload.sender,
tx.payload.as_builder().to_bytes_packed(),
tx.metadata.signature):
raise TransactionSignatureInvalid
# Check nonce processor is correct
if tx.payload.processor != expected_processor:
raise TransactionProcessorInvalid
# Attempt to get the current block's pending nonce
nonce = driver.get_nonce(tx.payload.processor, tx.payload.sender) or 0
pending_nonce = driver.get_pending_nonce(tx.payload.processor,
tx.payload.sender) or nonce
if tx.payload.nonce - nonce > tx_per_block or pending_nonce - nonce >= tx_per_block:
raise TransactionTooManyPendingException
# Strict mode requires exact sequence matching (1, 2, 3, 4). This is for masternodes
if strict:
if tx.payload.nonce != pending_nonce:
raise TransactionNonceInvalid
pending_nonce += 1
# However, some of those tx's might fail verification and never make it to delegates. Thus,
# delegates shouldn't be as concerned. (1, 2, 4) should be valid for delegates.
else:
if tx.payload.nonce < pending_nonce:
raise TransactionNonceInvalid
pending_nonce = tx.payload.nonce + 1
# Validate Stamps
if tx.payload.stampsSupplied < 0:
raise TransactionStampsNegative
currency_contract = 'currency'
balances_hash = 'balances'
balances_key = '{}{}{}{}{}'.format(currency_contract,
config.INDEX_SEPARATOR,
balances_hash, config.DELIMITER,
tx.payload.sender.hex())
balance = driver.get(balances_key)
if balance is None:
balance = 0
stamp_to_tau = driver.get_var('stamp_cost', 'S', ['value'])
if stamp_to_tau is None:
stamp_to_tau = 1
if balance * stamp_to_tau < tx.payload.stampsSupplied:
print("bal -> {}, stamp2tau - > {}, txpayload -> {}".format(
balance, stamp_to_tau, tx.payload.stampsSupplied))
raise TransactionSenderTooFewStamps
# Prevent people from sending their entire balances for free by checking if that is what they are doing.
if tx.payload.contractName == 'currency' and tx.payload.functionName == 'transfer':
kwargs = decode(tx.payload.kwargs)
amount = kwargs.get('amount')
# If you have less than 2 transactions worth of tau after trying to send your amount, fail.
if ((balance - amount) * stamp_to_tau) / 3000 < 2:
print(f'BAL IS: {((balance - amount) * stamp_to_tau) / 3000}')
raise TransactionSenderTooFewStamps
if tx.payload.contractName == 'submission' and tx.payload.functionName == 'submit_contract':
kwargs = decode(tx.payload.kwargs)
name = kwargs.get('name')
if type(name) != str:
raise TransactionContractNameInvalid
if not name.startswith('con_'):
raise TransactionContractNameInvalid
driver.set_pending_nonce(tx.payload.processor, tx.payload.sender,
pending_nonce)
class TestTXValidity(TestCase):
def setUp(self):
self.nonce_manager = BlockchainDriver()
self.nonce_manager.flush()
def tearDown(self):
self.nonce_manager.flush()
def test_processor_incorrect_returns_false(self):
w = Wallet()
expected_processor = secrets.token_bytes(32)
given_processor = secrets.token_bytes(32)
tx = TransactionBuilder(w.verifying_key(),
contract='currency',
function='transfer',
kwargs={'amount': 10, 'to': 'jeff'},
stamps=500000,
processor=given_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.TransactionProcessorInvalid):
transaction_is_valid(tx=tx_struct, expected_processor=expected_processor, driver=self.nonce_manager)
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_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 test_all_but_wallet_signed_returns_false(self):
w = Wallet()
x = Wallet()
expected_processor = secrets.token_bytes(32)
tx = TransactionBuilder(w.verifying_key(),
contract='currency',
function='transfer',
kwargs={'amount': 10, 'to': 'jeff'},
stamps=0,
processor=expected_processor,
nonce=0)
tx.sign(x.signing_key())
tx_bytes = tx.serialize()
tx_struct = transaction_capnp.NewTransaction.from_bytes_packed(tx_bytes)
with self.assertRaises(transaction.TransactionSignatureInvalid):
transaction_is_valid(tx=tx_struct, expected_processor=expected_processor, driver=self.nonce_manager)
def test_all_but_proof_valid_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=0,
processor=expected_processor,
nonce=0)
tx.proof = b'\00' * 32
tx.proof_generated = True
tx.sign(w.signing_key())
tx_bytes = tx.serialize()
tx_struct = transaction_capnp.NewTransaction.from_bytes_packed(tx_bytes)
with self.assertRaises(transaction.TransactionPOWProofInvalid):
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_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_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)
def test_non_sequence_fails_in_strict_mode(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=5)
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_greater_than_passes_in_no_strict_mode(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=5)
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)
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_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)
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)
def test_tx_nonce_minus_nonce_less_than_tx_per_block(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=2)
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)
def test_tx_nonce_minus_nonce_greater_than_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=10)
tx = TransactionBuilder(w.verifying_key(),
contract='currency',
function='transfer',
kwargs={'amount': 10, 'to': 'jeff'},
stamps=500000,
processor=expected_processor,
nonce=20)
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_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_15_in_row_valid_16th_not_due_to_tx_per_block_failing(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)
for i in range(15):
tx = TransactionBuilder(w.verifying_key(),
contract='currency',
function='transfer',
kwargs={'amount': 10, 'to': 'jeff'},
stamps=500000,
processor=expected_processor,
nonce=i)
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=15)
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_sending_transfer_of_all_money_fails(self):
self.nonce_manager.set_var('stamp_cost', 'S', ['value'], value=3000)
stamp_to_tau = self.nonce_manager.get_var('stamp_cost', 'S', ['value'])
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': 500000, '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)
with self.assertRaises(transaction.TransactionSenderTooFewStamps):
transaction_is_valid(tx=tx_struct, expected_processor=expected_processor, driver=self.nonce_manager)
def test_sending_transfer_of_most_money_fails_if_only_one_transfer_in_stamps_left(self):
self.nonce_manager.set_var('stamp_cost', 'S', ['value'], value=3000)
stamp_to_tau = self.nonce_manager.get_var('stamp_cost', 'S', ['value'])
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': 499999, '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)
with self.assertRaises(transaction.TransactionSenderTooFewStamps):
transaction_is_valid(tx=tx_struct, expected_processor=expected_processor, driver=self.nonce_manager)
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_submission_not_prepended_with_con_throws_error(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': '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)
with self.assertRaises(transaction.TransactionContractNameInvalid):
transaction_is_valid(tx=tx_struct, expected_processor=expected_processor, driver=self.nonce_manager)
def test_submission_not_str_throws_error(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': 123, '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)
with self.assertRaises(transaction.TransactionContractNameInvalid):
transaction_is_valid(tx=tx_struct, expected_processor=expected_processor, driver=self.nonce_manager)
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)