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_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_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_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)