def test_events():
# create multiple nac instances and assert they are different contracts
state = tester.state()
nc.registry.register(EventNAC)
# create proxies
nc.listen_logs(state, Shout)
c0 = nc.tester_nac(state, tester.k0, EventNAC.address)
c0.afunc(1, 2)
def test_events():
# create multiple nac instances and assert they are different contracts
state = tester.state()
nc.registry.register(EventNAC)
# create proxies
nc.listen_logs(state, Shout)
c0 = nc.tester_nac(state, tester.k0, EventNAC.address)
c0.afunc(1, 2)
def test_owned():
class TestTSC(nc.NativeContract):
address = utils.int_to_addr(2051)
owner = nc.Scalar('address')
def own(ctx, returns=None):
if ctx.owner == '\0' * 20:
ctx.owner = ctx.tx_origin
assert ctx.owner == ctx.tx_origin
def assert_owner(ctx):
if ctx.tx_origin != ctx.owner:
raise RuntimeError('not owner')
@nc.constant
def protected(ctx, returns='uint32'):
ctx.assert_owner()
return 1
assert TestTSC.protected.is_constant == True
state = tester.state()
nc.registry.register(TestTSC)
a0 = nc.tester_create_native_contract_instance(state, tester.k0, TestTSC)
c0 = nc.tester_nac(state, tester.k0, a0)
c0.own()
assert c0.protected() == 1
c0k1 = nc.tester_nac(state, tester.k1, a0)
try:
c0k1.protected()
except tester.TransactionFailed:
pass
else:
assert False, 'must not access protected if not owner'
nc.registry.unregister(TestTSC)
def test_owned():
class TestTSC(nc.NativeContract):
address = utils.int_to_addr(2051)
owner = nc.Scalar('address')
def own(ctx, returns=None):
if ctx.owner == '\0' * 20:
ctx.owner = ctx.tx_origin
assert ctx.owner == ctx.tx_origin
def assert_owner(ctx):
if ctx.tx_origin != ctx.owner:
raise RuntimeError('not owner')
@nc.constant
def protected(ctx, returns='uint32'):
ctx.assert_owner()
return 1
assert TestTSC.protected.is_constant is True
state = tester.state()
nc.registry.register(TestTSC)
a0 = nc.tester_create_native_contract_instance(state, tester.k0, TestTSC)
c0 = nc.tester_nac(state, tester.k0, a0)
c0.own()
assert c0.protected() == 1
c0k1 = nc.tester_nac(state, tester.k1, a0)
try:
c0k1.protected()
except tester.TransactionFailed:
pass
else:
assert False, 'must not access protected if not owner'
nc.registry.unregister(TestTSC)
def test_nac_instances():
# create multiple nac instances and assert they are different contracts
state = tester.state()
nc.registry.register(SampleNAC)
a0 = nc.tester_create_native_contract_instance(state, tester.k0, SampleNAC)
a1 = nc.tester_create_native_contract_instance(state, tester.k0, SampleNAC)
a2 = nc.tester_create_native_contract_instance(state, tester.k0, SampleNAC)
assert a0 != a1 != a2
assert len(a0) == 20
# create proxies
c0 = nc.tester_nac(state, tester.k0, a0)
c1 = nc.tester_nac(state, tester.k0, a1)
c2 = nc.tester_nac(state, tester.k0, a2)
assert c0.get_address() == a0
assert c1.get_address() == a1
assert c2.get_address() == a2
assert c0.afunc(5, 6) == 30
assert c0.efunc([4, 8]) == 32
nc.registry.unregister(SampleNAC)
def test_nac_instances():
# create multiple nac instances and assert they are different contracts
state = tester.state()
nc.registry.register(SampleNAC)
a0 = nc.tester_create_native_contract_instance(state, tester.k0, SampleNAC)
a1 = nc.tester_create_native_contract_instance(state, tester.k0, SampleNAC)
a2 = nc.tester_create_native_contract_instance(state, tester.k0, SampleNAC)
assert a0 != a1 != a2
assert len(a0) == 20
# create proxies
c0 = nc.tester_nac(state, tester.k0, a0)
c1 = nc.tester_nac(state, tester.k0, a1)
c2 = nc.tester_nac(state, tester.k0, a2)
assert c0.get_address() == a0
assert c1.get_address() == a1
assert c2.get_address() == a2
assert c0.afunc(5, 6) == 30
assert c0.efunc([4, 8]) == 32
nc.registry.unregister(SampleNAC)
def test_fungible_instance():
state = tester.state()
creator_address = tester.a0
creator_key = tester.k0
nc.registry.register(Fungible)
# Create proxy
EUR_address = nc.tester_create_native_contract_instance(
state, creator_key, Fungible)
fungible_as_creator = nc.tester_nac(state, creator_key, EUR_address)
# Initalize fungible with a fixed quantity of fungibles.
fungible_total = 1000000
fungible_as_creator.init(fungible_total)
assert fungible_as_creator.balanceOf(creator_address) == fungible_total
nc.registry.unregister(Fungible)
def test_iou_template():
"""
Tests;
IOU initialization as Issuer,
Testing issue funds, get_issued_amount
"""
# Register Contract Fungible
nc.registry.register(IOU)
# Initialize Participants and Fungible contract
state = tester.state()
logs = []
issuer_address = tester.a0
issuer_key = tester.k0
# create listeners
for evt_class in IOU.events:
nc.listen_logs(state, evt_class, callback=lambda e: logs.append(e))
# Initialization
iou_address = nc.tester_create_native_contract_instance(
state, issuer_key, IOU)
iou_as_issuer = nc.tester_nac(state, issuer_key, iou_address)
iou_as_issuer.init()
assert iou_as_issuer.balanceOf(issuer_address) == 0
amount_issued = 200000
iou_as_issuer.issue_funds(amount_issued, '')
assert iou_as_issuer.balanceOf(issuer_address) == amount_issued
iou_as_issuer.issue_funds(amount_issued, '')
assert iou_as_issuer.balanceOf(issuer_address) == 2 * amount_issued
assert iou_as_issuer.get_issued_amount(issuer_address) == 2 * amount_issued
print logs
while logs and logs.pop():
pass
nc.registry.unregister(IOU)
def test_fungible_template():
"""
Tests;
Fungible initialization as Creator,
Creator sends Fungibles to Alice,
Alice sends Fungibles to Bob,
Bob approves Creator to spend Fungibles on his behalf,
Creator allocates these Fungibles from Bob to Alice,
Testing of non-standardized functions of the Fungible contract.
Events;
Checking logs from Transfer and Approval Events
"""
# Register Contract Fungible
nc.registry.register(Fungible)
# Initialize Participants and Fungible contract
state = tester.state()
logs = []
creator_address = tester.a0
creator_key = tester.k0
alice_address = tester.a1
alice_key = tester.k1
bob_address = tester.a2
bob_key = tester.k2
# Create proxy
nc.listen_logs(state, Transfer, callback=lambda e: logs.append(e))
nc.listen_logs(state, Approval, callback=lambda e: logs.append(e))
fungible_as_creator = nc.tester_nac(state, creator_key, Fungible.address)
# Initalize fungible with a fixed quantity of fungibles.
fungible_total = 1000000
fungible_as_creator.init(fungible_total)
assert fungible_as_creator.balanceOf(creator_address) == fungible_total
# Creator transfers Fungibles to Alice
send_amount_alice = 700000
fungible_as_creator.transfer(alice_address, send_amount_alice)
assert fungible_as_creator.balanceOf(
creator_address) == fungible_total - send_amount_alice
assert fungible_as_creator.balanceOf(alice_address) == send_amount_alice
# Check logs data of Transfer Event
assert len(logs) == 1
l = logs[0]
assert l['event_type'] == 'Transfer'
assert l['from'] == creator_address
assert l['to'] == alice_address
# Build transaction Log arguments and check sent amount
assert l['value'] == send_amount_alice
# Alice transfers Fungibles to Bob
send_amount_bob = 400000
# Create proxy for Alice
fungible_as_alice = nc.tester_nac(state, alice_key, Fungible.address)
fungible_as_alice.transfer(bob_address, send_amount_bob)
# Test balances of Creator, Alice and Bob
creator_balance = fungible_total - send_amount_alice
alice_balance = send_amount_alice - send_amount_bob
bob_balance = send_amount_bob
assert fungible_as_alice.balanceOf(creator_address) == creator_balance
assert fungible_as_alice.balanceOf(alice_address) == alice_balance
assert fungible_as_alice.balanceOf(bob_address) == bob_balance
# Create proxy for Bob
fungible_as_bob = nc.tester_nac(state, bob_key, Fungible.address)
approved_amount_bob = 100000
assert fungible_as_bob.allowance(creator_address) == 0
# Bob approves Creator to spend Fungibles
assert fungible_as_bob.allowance(creator_address) == 0
fungible_as_bob.approve(creator_address, approved_amount_bob)
assert fungible_as_bob.allowance(creator_address) == approved_amount_bob
# Test transferFrom function, i.e. direct debit.
fungible_as_creator.transferFrom(bob_address, alice_address,
approved_amount_bob)
# Test balances
alice_balance += approved_amount_bob
bob_balance -= approved_amount_bob
assert fungible_as_alice.balanceOf(creator_address) == creator_balance
assert fungible_as_alice.balanceOf(alice_address) == alice_balance
assert fungible_as_alice.balanceOf(bob_address) == bob_balance
# Check logs data of Transfer Event
assert len(logs) == 4
l = logs[-1]
assert l['event_type'] == 'Transfer'
assert l['from'] == bob_address
assert l['to'] == alice_address
# Build transaction Log arguments and check sent amount
assert l['value'] == approved_amount_bob
# Testing account information
# Now we should have three Fungible accounts
assert 3 == fungible_as_alice.num_accounts()
r = fungible_as_creator.get_creator()
assert r == creator_address
r = fungible_as_creator.get_accounts()
assert set(r) == set([creator_address, alice_address, bob_address])
print logs
while logs and logs.pop():
pass
nc.registry.unregister(Fungible)
def test_nativeabicontract_with_storage():
class TestTSC(nc.NativeContract):
address = utils.int_to_addr(2051)
size = nc.Scalar('uint32')
numbers = nc.List('uint32')
words = nc.Dict('bytes')
def setup_numbers(ctx, size='uint32', returns=None):
ctx.size = size
assert isinstance(ctx.numbers, nc.List)
for i in range(size):
ctx.numbers.append(i)
def sum_numbers(ctx, returns='uint32'):
assert ctx.size == len(ctx.numbers)
return sum(ctx.numbers[i] for i in range(len(ctx.numbers)))
def setup_words(ctx, num='uint32', returns=None):
for i in range(num):
key = 'key%d' % i
word = 'word%d' % i
ctx.words[key] = word
assert ctx.words[key] == word
def get_word(ctx, key='bytes', returns='bytes'):
r = ctx.words[key]
return r
def muladdsize(ctx, val='uint32', returns='uint32'):
ctx.size += val
ctx.size *= val
return ctx.size
state = tester.state()
nc.registry.register(TestTSC)
# deploy two instances
a0 = nc.tester_create_native_contract_instance(state, tester.k0, TestTSC)
a1 = nc.tester_create_native_contract_instance(state, tester.k0, TestTSC)
# create proxies
c0 = nc.tester_nac(state, tester.k0, a0)
c1 = nc.tester_nac(state, tester.k0, a1)
size = 20
c0.setup_numbers(size)
assert c1.sum_numbers() == 0
assert c0.sum_numbers() == sum(range(size))
c1.setup_numbers(size)
assert c0.sum_numbers() == sum(range(size))
assert c1.sum_numbers() == sum(range(size))
param = 5
assert c0.muladdsize(param) == (size + param) * param
# words
c1.setup_words(param)
assert c1.get_word(b'key2') == b'word2'
assert c0.get_word(b'key2') == b''
c0.setup_words(param)
assert c0.get_word(b'key2') == b'word2'
nc.registry.unregister(TestTSC)
def test_nativeabicontract_with_storage():
class TestTSC(nc.NativeContract):
address = utils.int_to_addr(2051)
size = nc.Scalar('uint32')
numbers = nc.List('uint32')
words = nc.Dict('bytes')
def setup_numbers(ctx, size='uint32', returns=None):
ctx.size = size
assert isinstance(ctx.numbers, nc.List)
for i in range(size):
ctx.numbers.append(i)
def sum_numbers(ctx, returns='uint32'):
assert ctx.size == len(ctx.numbers)
return sum(ctx.numbers[i] for i in range(len(ctx.numbers)))
def setup_words(ctx, num='uint32', returns=None):
for i in range(num):
key = 'key%d' % i
word = 'word%d' % i
ctx.words[key] = word
assert ctx.words[key] == word
def get_word(ctx, key='bytes', returns='bytes'):
r = ctx.words[key]
return r
def muladdsize(ctx, val='uint32', returns='uint32'):
ctx.size += val
ctx.size *= val
return ctx.size
state = tester.state()
nc.registry.register(TestTSC)
# deploy two instances
a0 = nc.tester_create_native_contract_instance(state, tester.k0, TestTSC)
a1 = nc.tester_create_native_contract_instance(state, tester.k0, TestTSC)
# create proxies
c0 = nc.tester_nac(state, tester.k0, a0)
c1 = nc.tester_nac(state, tester.k0, a1)
size = 20
c0.setup_numbers(size)
assert c1.sum_numbers() == 0
assert c0.sum_numbers() == sum(range(size))
c1.setup_numbers(size)
assert c0.sum_numbers() == sum(range(size))
assert c1.sum_numbers() == sum(range(size))
param = 5
assert c0.muladdsize(param) == (size + param) * param
# words
c1.setup_words(param)
assert c1.get_word(b'key2') == b'word2'
assert c0.get_word(b'key2') == b''
c0.setup_words(param)
assert c0.get_word(b'key2') == b'word2'
nc.registry.unregister(TestTSC)