def arguments_for_balance_of(receiver, reqs):
return (sp.record(
callback = sp.contract(
Balance_of.response_type(),
sp.contract_address(receiver),
entry_point = "receive_balances").open_some(),
requests = reqs))
def test_is_operator(scenario, owner, operator, tokens, valid, comment):
scenario.p("test_is_operator: " + comment )
is_operator = Operator_param.make(
owner = owner.address,
operator = operator.address,
tokens = tokens)
scenario += c1.is_operator(
sp.record(
callback = sp.contract(
Operator_param.is_operator_response_type(),
sp.contract_address(consumer),
entry_point = "receive_is_operator").open_some(),
operator = is_operator
))
scenario.verify(consumer.data.last_operator == valid)
def test():
scenario = sp.test_scenario()
scenario.h1("Simple FA2 Contract")
# sp.test_account generates ED25519 key-pairs deterministically:
admin = sp.test_account("Administrator")
alice = sp.test_account("Alice")
bob = sp.test_account("Robert")
# Let's display the accounts:
scenario.h2("Accounts")
scenario.show([admin, alice, bob])
c1 = FA2(admin.address)
scenario += c1
scenario.h2("Initial Minting")
scenario.p("The administrator mints 100 token-0's to Alice.")
scenario += c1.mint(address = alice.address,
amount = 100,
symbol = 'TK0',
token_id = 0).run(sender = admin)
scenario.h2("Transfers Alice -> Bob")
scenario += c1.transfer(
[
Transfer.make(alice.address,
bob.address,
a = 10,
i = 0)
]).run(sender = alice)
scenario.verify(
c1.data.ledger[Ledger_key.make(alice.address, 0)].balance == 90)
scenario.verify(
c1.data.ledger[Ledger_key.make(bob.address, 0)].balance == 10)
scenario += c1.transfer(
[
Transfer.make(alice.address,
bob.address,
a = 10,
i = 0),
Transfer.make(alice.address,
bob.address,
a = 11,
i = 0)
]).run(sender = alice)
scenario.verify(
c1.data.ledger[Ledger_key.make(alice.address, 0)].balance
== 90 - 10 - 11)
scenario.verify(
c1.data.ledger[Ledger_key.make(bob.address, 0)].balance
== 10 + 10 + 11)
scenario.h2("More Token Types")
scenario += c1.mint(address = bob.address,
amount = 100,
symbol = 'TK1',
token_id = 1).run(sender = admin)
scenario += c1.mint(address = bob.address,
amount = 200,
symbol = 'TK2',
token_id = 2).run(sender = admin)
scenario.h3("Multi-token Transfer Bob -> Alice")
scenario += c1.transfer(
[
Transfer.make(bob.address,
alice.address,
a = 10,
i = 0),
Transfer.make(bob.address,
alice.address,
a = 10,
i = 1),
Transfer.make(bob.address,
alice.address,
a = 10,
i = 2)
]).run(sender = bob)
scenario.h2("Other Basic Permission Tests")
scenario.h3("Bob cannot transfer Alice's tokens.")
scenario += c1.transfer(
[
Transfer.make(alice.address,
bob.address,
a = 10,
i = 0),
Transfer.make(alice.address,
bob.address,
a = 11,
i = 0)
]).run(sender = bob, valid = False)
scenario.h3("Admin can transfer anything.")
scenario += c1.transfer(
[
Transfer.make(alice.address,
bob.address,
a = 10,
i = 0),
Transfer.make(alice.address,
bob.address,
a = 10,
i = 1),
Transfer.make(bob.address,
alice.address,
a = 11,
i = 0)
]).run(sender = admin)
scenario.h3("Even Admin cannot transfer too much.")
scenario += c1.transfer(
[
Transfer.make(alice.address,
bob.address,
a = 1000,
i = 0)
]).run(sender = admin, valid = False)
scenario.h3("Consumer Contract for Callback Calls.")
consumer = View_consumer()
scenario += consumer
scenario.p("Consumer virtual address: "
+ sp.contract_address(consumer).export())
scenario.h2("Balance-of.")
scenario += c1.balance_of(arguments_for_balance_of(consumer, [
sp.record(owner = alice.address, token_id = 0),
sp.record(owner = alice.address, token_id = 1),
sp.record(owner = alice.address, token_id = 2)
]))
scenario.verify(consumer.data.last_sum == 90)
scenario.h2("Total Supply.")
scenario += c1.total_supply(
sp.record(
callback = sp.contract(
Total_supply.response_type(),
sp.contract_address(consumer),
entry_point = "receive_total_supplies").open_some(),
token_ids = [0, 1]))
scenario.verify(consumer.data.last_sum == 200)
scenario.h2("Token Metadata.")
scenario += c1.token_metadata(
sp.record(
callback = sp.contract(
sp.TList(Token_meta_data.get_type()),
sp.contract_address(consumer),
entry_point = "receive_metadata").open_some(),
token_ids = [0, 1]))
scenario.verify(consumer.data.last_acc == "TK0TK1")
scenario.h2("Operators")
if not support_operator:
scenario.h3("This version was compiled with no operator support")
scenario.p("Calls should fail even for the administrator:")
scenario += c1.update_operators([]).run(sender = admin, valid = False)
scenario += c1.permissions_descriptor(
sp.contract(
Permissions_descriptor.get_type(),
sp.contract_address(consumer),
entry_point = "receive_permissions_descriptor").open_some())
scenario.verify(consumer.data.operator_support == False)
else:
scenario.p("This version was compiled with operator support")
scenario += c1.update_operators([]).run(sender = admin)
scenario.h3("Operator Accounts")
op0 = sp.test_account("Operator0")
op1 = sp.test_account("Operator1")
op2 = sp.test_account("Operator2")
scenario.show([op0, op1, op2])
scenario.p("Admin can change Alice's operator.")
scenario += c1.update_operators([
sp.variant("Add_operator", Operator_param.make(
owner = alice.address,
operator = op1.address))
]).run(sender = admin)
scenario.p("Operator1 can transfer Alice's tokens")
scenario += c1.transfer(
[
Transfer.make(alice.address,
bob.address,
a = 2,
i = 0),
Transfer.make(alice.address,
op1.address,
a = 2,
i = 2)
]).run(sender = op1)
scenario.p("Operator1 cannot transfer Bob's tokens")
scenario += c1.transfer(
[
Transfer.make(bob.address,
op1.address,
a = 2,
i = 1)
]).run(sender = op1, valid = False)
scenario.p("Operator2 cannot transfer Alice's tokens")
scenario += c1.transfer(
[
Transfer.make(alice.address,
bob.address,
a = 2,
i = 1)
]).run(sender = op2, valid = False)
scenario.p("Alice can remove their operator")
scenario += c1.update_operators([
sp.variant("Remove_operator", Operator_param.make(
owner = alice.address,
operator = op1.address))
]).run(sender = alice)
scenario.p("Operator1 cannot transfer Alice's tokens any more")
scenario += c1.transfer(
[
Transfer.make(alice.address,
op1.address,
a = 2,
i = 1)
]).run(sender = op1, valid = False)
scenario.p("Bob can add Operator0 only for token 0 and 1.")
scenario += c1.update_operators([
sp.variant("Add_operator", Operator_param.make(
owner = bob.address,
operator = op0.address,
tokens = sp.set([0,1])
))
]).run(sender = bob)
scenario.p("Operator0 can transfer Bob's tokens '0' and '1'")
scenario += c1.transfer(
[
Transfer.make(bob.address,
alice.address,
a = 1,
i = 0),
Transfer.make(bob.address,
alice.address,
a = 1,
i = 1)
]).run(sender = op0)
scenario.p("Operator0 cannot transfer Bob's tokens '2'")
scenario += c1.transfer(
[
Transfer.make(bob.address,
alice.address,
a = 1,
i = 2)
]).run(sender = op0, valid = False)
scenario.p("Bob cannot add Operator0 for Alice's tokens.")
scenario += c1.update_operators([
sp.variant("Add_operator", Operator_param.make(
owner = alice.address,
operator = op0.address,
tokens = sp.set([0,1])
))
]).run(sender = bob, valid = False)
scenario.h3("Testing is_operator")
scenario.p("Operator0 is still active for Bob's 0 and 1, \
Alice has no operator")
def test_is_operator(scenario, owner, operator, tokens, valid, comment):
scenario.p("test_is_operator: " + comment )
is_operator = Operator_param.make(
owner = owner.address,
operator = operator.address,
tokens = tokens)
scenario += c1.is_operator(
sp.record(
callback = sp.contract(
Operator_param.is_operator_response_type(),
sp.contract_address(consumer),
entry_point = "receive_is_operator").open_some(),
operator = is_operator
))
scenario.verify(consumer.data.last_operator == valid)
test_is_operator(scenario, bob, op0, sp.set([0, 1]), True,
"bob, op0, [0,1]")
test_is_operator(scenario, bob, op0, sp.set([0]), True,
"bob, op0, [0]")
test_is_operator(scenario, bob, op0, sp.set([0, 2]), False,
"bob, op0, [0,2]")
test_is_operator(scenario, bob, op0, None, False,
"bob, op0, all")
test_is_operator(scenario, alice, op0, None, False,
"alice, op0, all")
scenario.h3("Testing permissions_descriptor")
scenario.verify(consumer.data.operator_support == False)
scenario += c1.permissions_descriptor(
sp.contract(
Permissions_descriptor.get_type(),
sp.contract_address(consumer),
entry_point = "receive_permissions_descriptor").open_some())
scenario.verify(consumer.data.operator_support == True)
def test():
scenario = sp.test_scenario()
scenario.h1("FA2 Contract Name: " + config.name)
scenario.table_of_contents()
# sp.test_account generates ED25519 key-pairs deterministically:
admin = sp.test_account("Administrator")
alice = sp.test_account("Alice")
bob = sp.test_account("Robert")
# Let's display the accounts:
scenario.h2("Accounts")
scenario.show([admin, alice, bob])
c1 = FA2(config, admin.address)
scenario += c1
if config.non_fungible:
# TODO
return
scenario.h2("Initial Minting")
scenario.p("The administrator mints 100 token-0's to Alice.")
scenario += c1.mint(address = alice.address,
amount = 100,
symbol = 'TK0',
token_id = 0).run(sender = admin)
scenario.h2("Transfers Alice -> Bob")
scenario += c1.transfer(
[
c1.batch_transfer.item(from_ = alice.address,
txs = [
sp.record(to_ = bob.address,
amount = 10,
token_id = 0)
])
]).run(sender = alice)
scenario.verify(
c1.data.ledger[c1.ledger_key.make(alice.address, 0)].balance == 90)
scenario.verify(
c1.data.ledger[c1.ledger_key.make(bob.address, 0)].balance == 10)
scenario += c1.transfer(
[
c1.batch_transfer.item(from_ = alice.address,
txs = [
sp.record(to_ = bob.address,
amount = 10,
token_id = 0),
sp.record(to_ = bob.address,
amount = 11,
token_id = 0)
])
]).run(sender = alice)
scenario.verify(
c1.data.ledger[c1.ledger_key.make(alice.address, 0)].balance
== 90 - 10 - 11)
scenario.verify(
c1.data.ledger[c1.ledger_key.make(bob.address, 0)].balance
== 10 + 10 + 11)
if config.single_asset:
return
scenario.h2("More Token Types")
scenario += c1.mint(address = bob.address,
amount = 100,
symbol = 'TK1',
token_id = 1).run(sender = admin)
scenario += c1.mint(address = bob.address,
amount = 200,
symbol = 'TK2',
token_id = 2).run(sender = admin)
scenario.h3("Multi-token Transfer Bob -> Alice")
scenario += c1.transfer(
[
c1.batch_transfer.item(from_ = bob.address,
txs = [
sp.record(to_ = alice.address,
amount = 10,
token_id = 0),
sp.record(to_ = alice.address,
amount = 10,
token_id = 1)]),
# We voluntarily test a different sub-batch:
c1.batch_transfer.item(from_ = bob.address,
txs = [
sp.record(to_ = alice.address,
amount = 10,
token_id = 2)])
]).run(sender = bob)
scenario.h2("Other Basic Permission Tests")
scenario.h3("Bob cannot transfer Alice's tokens.")
scenario += c1.transfer(
[
c1.batch_transfer.item(from_ = alice.address,
txs = [
sp.record(to_ = bob.address,
amount = 10,
token_id = 0),
sp.record(to_ = bob.address,
amount = 1,
token_id = 0)])
]).run(sender = bob, valid = False)
scenario.h3("Admin can transfer anything.")
scenario += c1.transfer(
[
c1.batch_transfer.item(from_ = alice.address,
txs = [
sp.record(to_ = bob.address,
amount = 10,
token_id = 0),
sp.record(to_ = bob.address,
amount = 10,
token_id = 1)]),
c1.batch_transfer.item(from_ = bob.address,
txs = [
sp.record(to_ = alice.address,
amount = 11,
token_id = 0)])
]).run(sender = admin)
scenario.h3("Even Admin cannot transfer too much.")
scenario += c1.transfer(
[
c1.batch_transfer.item(from_ = alice.address,
txs = [
sp.record(to_ = bob.address,
amount = 1000,
token_id = 0)])
]).run(sender = admin, valid = False)
scenario.h3("Consumer Contract for Callback Calls.")
consumer = View_consumer(c1)
scenario += consumer
scenario.p("Consumer virtual address: "
+ sp.contract_address(consumer).export())
scenario.h2("Balance-of.")
def arguments_for_balance_of(receiver, reqs):
return (sp.record(
callback = sp.contract(
Balance_of.response_type(),
sp.contract_address(receiver),
entry_point = "receive_balances").open_some(),
requests = reqs))
scenario += c1.balance_of(arguments_for_balance_of(consumer, [
sp.record(owner = alice.address, token_id = 0),
sp.record(owner = alice.address, token_id = 1),
sp.record(owner = alice.address, token_id = 2)
]))
scenario.verify(consumer.data.last_sum == 90)
scenario.h2("Token Metadata.")
scenario.p("The view-receiver does the verification that the address"
+ "received is the one of the FA2 contract.")
scenario += c1.token_metadata_registry(
sp.contract(
sp.TAddress,
sp.contract_address(consumer),
entry_point = "receive_metadata_registry").open_some())
def check_metadata_list(l):
res = sp.local("toks", sp.string(""))
sp.for md in l:
res.value = sp.concat([md.symbol, res.value])
sp.verify((md.symbol == "TK0") | (md.symbol == "TK1"))
sp.verify(res.value == "TK1TK0")
def add_test(config, is_default = True):
@sp.add_test(name = config.name, is_default = is_default)
def test():
scenario = sp.test_scenario()
scenario.h1("FA2 Contract Name: " + config.name)
scenario.table_of_contents()
# sp.test_account generates ED25519 key-pairs deterministically:
admin = sp.test_account("Administrator")
alice = sp.test_account("Alice")
bob = sp.test_account("Robert")
# Let's display the accounts:
scenario.h2("Accounts")
scenario.show([admin, alice, bob])
c1 = FA2(config, admin.address)
scenario += c1
if config.non_fungible:
# TODO
return
scenario.h2("Initial Minting")
scenario.p("The administrator mints 100 token-0's to Alice.")
scenario += c1.mint(address = alice.address,
amount = 100,
symbol = 'TK0',
token_id = 0).run(sender = admin)
scenario.h2("Transfers Alice -> Bob")
scenario += c1.transfer(
[
c1.batch_transfer.item(from_ = alice.address,
txs = [
sp.record(to_ = bob.address,
amount = 10,
token_id = 0)
])
]).run(sender = alice)
scenario.verify(
c1.data.ledger[c1.ledger_key.make(alice.address, 0)].balance == 90)
scenario.verify(
c1.data.ledger[c1.ledger_key.make(bob.address, 0)].balance == 10)
scenario += c1.transfer(
[
c1.batch_transfer.item(from_ = alice.address,
txs = [
sp.record(to_ = bob.address,
amount = 10,
token_id = 0),
sp.record(to_ = bob.address,
amount = 11,
token_id = 0)
])
]).run(sender = alice)
scenario.verify(
c1.data.ledger[c1.ledger_key.make(alice.address, 0)].balance
== 90 - 10 - 11)
scenario.verify(
c1.data.ledger[c1.ledger_key.make(bob.address, 0)].balance
== 10 + 10 + 11)
if config.single_asset:
return
scenario.h2("More Token Types")
scenario += c1.mint(address = bob.address,
amount = 100,
symbol = 'TK1',
token_id = 1).run(sender = admin)
scenario += c1.mint(address = bob.address,
amount = 200,
symbol = 'TK2',
token_id = 2).run(sender = admin)
scenario.h3("Multi-token Transfer Bob -> Alice")
scenario += c1.transfer(
[
c1.batch_transfer.item(from_ = bob.address,
txs = [
sp.record(to_ = alice.address,
amount = 10,
token_id = 0),
sp.record(to_ = alice.address,
amount = 10,
token_id = 1)]),
# We voluntarily test a different sub-batch:
c1.batch_transfer.item(from_ = bob.address,
txs = [
sp.record(to_ = alice.address,
amount = 10,
token_id = 2)])
]).run(sender = bob)
scenario.h2("Other Basic Permission Tests")
scenario.h3("Bob cannot transfer Alice's tokens.")
scenario += c1.transfer(
[
c1.batch_transfer.item(from_ = alice.address,
txs = [
sp.record(to_ = bob.address,
amount = 10,
token_id = 0),
sp.record(to_ = bob.address,
amount = 1,
token_id = 0)])
]).run(sender = bob, valid = False)
scenario.h3("Admin can transfer anything.")
scenario += c1.transfer(
[
c1.batch_transfer.item(from_ = alice.address,
txs = [
sp.record(to_ = bob.address,
amount = 10,
token_id = 0),
sp.record(to_ = bob.address,
amount = 10,
token_id = 1)]),
c1.batch_transfer.item(from_ = bob.address,
txs = [
sp.record(to_ = alice.address,
amount = 11,
token_id = 0)])
]).run(sender = admin)
scenario.h3("Even Admin cannot transfer too much.")
scenario += c1.transfer(
[
c1.batch_transfer.item(from_ = alice.address,
txs = [
sp.record(to_ = bob.address,
amount = 1000,
token_id = 0)])
]).run(sender = admin, valid = False)
scenario.h3("Consumer Contract for Callback Calls.")
consumer = View_consumer(c1)
scenario += consumer
scenario.p("Consumer virtual address: "
+ sp.contract_address(consumer).export())
scenario.h2("Balance-of.")
def arguments_for_balance_of(receiver, reqs):
return (sp.record(
callback = sp.contract(
Balance_of.response_type(),
sp.contract_address(receiver),
entry_point = "receive_balances").open_some(),
requests = reqs))
scenario += c1.balance_of(arguments_for_balance_of(consumer, [
sp.record(owner = alice.address, token_id = 0),
sp.record(owner = alice.address, token_id = 1),
sp.record(owner = alice.address, token_id = 2)
]))
scenario.verify(consumer.data.last_sum == 90)
scenario.h2("Token Metadata.")
scenario.p("The view-receiver does the verification that the address"
+ "received is the one of the FA2 contract.")
scenario += c1.token_metadata_registry(
sp.contract(
sp.TAddress,
sp.contract_address(consumer),
entry_point = "receive_metadata_registry").open_some())
def check_metadata_list(l):
res = sp.local("toks", sp.string(""))
sp.for md in l:
res.value = sp.concat([md.symbol, res.value])
sp.verify((md.symbol == "TK0") | (md.symbol == "TK1"))
sp.verify(res.value == "TK1TK0")
scenario += c1.token_metadata(
sp.record(
token_ids = [0, 1],
handler = check_metadata_list
))
scenario.h2("Operators")
if not c1.config.support_operator:
scenario.h3("This version was compiled with no operator support")
scenario.p("Calls should fail even for the administrator:")
scenario += c1.update_operators([]).run(sender = admin, valid = False)
if config.add_permissions_descriptor:
scenario += c1.permissions_descriptor(
sp.contract(
c1.permissions_descriptor_.get_type(),
sp.contract_address(consumer),
entry_point = "receive_permissions_descriptor"
).open_some())
scenario.verify(consumer.data.operator_support == False)
else:
scenario.p("This version was compiled with operator support.")
scenario.p("Calling 0 updates should work:")
scenario += c1.update_operators([]).run()
scenario.h3("Operator Accounts")
op0 = sp.test_account("Operator0")
op1 = sp.test_account("Operator1")
op2 = sp.test_account("Operator2")
scenario.show([op0, op1, op2])
scenario.p("Admin can change Alice's operator.")
scenario += c1.update_operators([
sp.variant("add_operator", c1.operator_param.make(
owner = alice.address,
operator = op1.address))
]).run(sender = admin)
scenario.p("Operator1 can now transfer Alice's tokens")
scenario += c1.transfer(
[
c1.batch_transfer.item(from_ = alice.address,
txs = [
sp.record(to_ = bob.address,
amount = 2,
token_id = 0),
sp.record(to_ = op1.address,
amount = 2,
token_id = 2)])
]).run(sender = op1)
scenario.p("Operator1 cannot transfer Bob's tokens")
scenario += c1.transfer(
[
c1.batch_transfer.item(from_ = bob.address,
txs = [
sp.record(to_ = op1.address,
amount = 2,
token_id = 1)])
]).run(sender = op1, valid = False)
scenario.p("Operator2 cannot transfer Alice's tokens")
scenario += c1.transfer(
[
c1.batch_transfer.item(from_ = alice.address,
txs = [
sp.record(to_ = bob.address,
amount = 2,
token_id = 1)])
]).run(sender = op2, valid = False)
scenario.p("Alice can remove their operator")
scenario += c1.update_operators([
sp.variant("remove_operator", c1.operator_param.make(
owner = alice.address,
operator = op1.address))
]).run(sender = alice)
scenario.p("Operator1 cannot transfer Alice's tokens any more")
scenario += c1.transfer(
[
c1.batch_transfer.item(from_ = alice.address,
txs = [
sp.record(to_ = op1.address,
amount = 2,
token_id = 1)])
]).run(sender = op1, valid = False)
scenario.p("Bob can add Operator0.")
scenario += c1.update_operators([
sp.variant("add_operator", c1.operator_param.make(
owner = bob.address,
operator = op0.address
))
]).run(sender = bob)
scenario.p("Operator0 can transfer Bob's tokens '0' and '1'")
scenario += c1.transfer(
[
c1.batch_transfer.item(from_ = bob.address,
txs = [
sp.record(to_ = alice.address,
amount = 1,
token_id = 0)]),
c1.batch_transfer.item(from_ = bob.address,
txs = [
sp.record(to_ = alice.address,
amount = 1,
token_id = 1)])
]).run(sender = op0)
scenario.p("Bob cannot add Operator0 for Alice's tokens.")
scenario += c1.update_operators([
sp.variant("add_operator", c1.operator_param.make(
owner = alice.address,
operator = op0.address
))
]).run(sender = bob, valid = False)
scenario.p("Alice can also add Operator0 for themselves.")
scenario += c1.update_operators([
sp.variant("add_operator", c1.operator_param.make(
owner = alice.address,
operator = op0.address
))
]).run(sender = alice, valid = True)
scenario.p("Operator0 can now transfer Bob's and Alice's tokens.")
scenario += c1.transfer(
[
c1.batch_transfer.item(from_ = bob.address,
txs = [
sp.record(to_ = alice.address,
amount = 1,
token_id = 0)]),
c1.batch_transfer.item(from_ = alice.address,
txs = [
sp.record(to_ = bob.address,
amount = 1,
token_id = 1)])
]).run(sender = op0)
scenario.p("Bob adds Operator2 as second operator.")
scenario += c1.update_operators([
sp.variant("add_operator", c1.operator_param.make(
owner = bob.address,
operator = op2.address
))
]).run(sender = bob, valid = True)
scenario.p("Operator0 and Operator2 can transfer Bob's tokens.")
scenario += c1.transfer(
[
c1.batch_transfer.item(from_ = bob.address,
txs = [
sp.record(to_ = alice.address,
amount = 1,
token_id = 0)])
]).run(sender = op0)
scenario += c1.transfer(
[
c1.batch_transfer.item(from_ = bob.address,
txs = [
sp.record(to_ = alice.address,
amount = 1,
token_id = 0)])
]).run(sender = op2)
if config.add_permissions_descriptor:
scenario.h3("Testing permissions_descriptor")
scenario.verify(consumer.data.operator_support == False)
scenario += c1.permissions_descriptor(
sp.contract(
c1.permissions_descriptor_.get_type(),
sp.contract_address(consumer),
entry_point = "receive_permissions_descriptor").open_some())
scenario.verify(consumer.data.operator_support == True)
scenario.table_of_contents()
def test():
scenario = sp.test_scenario()
scenario.h1("Fishcake Token")
scenario.table_of_contents()
admin = sp.test_account("Administrator")
alice = sp.test_account("Alice")
bob = sp.test_account("Bob")
scenario.h2("Accounts")
scenario.show([admin, alice, bob])
c1 = Fishcake(admin.address, 100)
scenario += c1
scenario.h2("Initial Minting")
scenario.p("The administrator mints the initial tokens")
scenario += c1.initialMint().run(sender=admin)
scenario += c1.initialMint().run(sender=admin, valid=False)
scenario.h2("Transfers Admin -> Bob")
scenario += c1.transfer(
[
c1.batch_transfer.item(from_=admin.address,
txs=[
sp.record(to_=bob.address,
amount=10,
token_id=0)
])
]).run(sender=admin)
scenario.verify(
c1.data.ledger[c1.ledger_key.make(admin.address, 0)].balance == 90)
scenario.verify(
c1.data.ledger[c1.ledger_key.make(bob.address, 0)].balance == 10)
scenario += c1.transfer(
[
c1.batch_transfer.item(from_=admin.address,
txs=[
sp.record(to_=bob.address,
amount=10,
token_id=0),
sp.record(to_=alice.address,
amount=11,
token_id=0)
])
]).run(sender=admin)
scenario.verify(
c1.data.ledger[c1.ledger_key.make(admin.address, 0)].balance
== 90 - 10 - 11)
scenario.verify(
c1.data.ledger[c1.ledger_key.make(bob.address, 0)].balance
== 10 + 10)
scenario.verify(
c1.data.ledger[c1.ledger_key.make(alice.address, 0)].balance
== 11)
scenario.h3("Consumer Contract for Callback Calls.")
consumer = View_consumer(c1)
scenario += consumer
scenario.p("Consumer virtual address: "
+ sp.contract_address(consumer).export())
scenario.h2("Balance-of.")
def arguments_for_balance_of(receiver, reqs):
return (sp.record(
callback=sp.contract(
Balance_of.response_type(),
sp.contract_address(receiver),
entry_point="receive_balances").open_some(),
requests=reqs))
scenario += c1.balance_of(arguments_for_balance_of(consumer, [
sp.record(owner=alice.address, token_id=0),
sp.record(owner=bob.address, token_id=0),
]))
scenario.verify(consumer.data.last_sum == 31)
scenario.h2("Token Metadata.")
scenario.p("The view-receiver does the verification that the address" +
"received is the one of the FA2 contract.")
scenario += c1.token_metadata_registry(
sp.contract(
sp.TAddress,
sp.contract_address(consumer),
entry_point="receive_metadata_registry").open_some())
def check_metadata_list(l):
res = sp.local("toks", sp.string(""))
sp.verify(sp.len(l) == 1)
sp.for md in l:
sp.verify((md.symbol == "FSCK") & (md.name == "Fishcake"))
