templates.fa2_lib_testing

   1import smartpy as sp
   2
   3admin = sp.test_account("Administrator")
   4admin2 = sp.test_account("Administrator2")
   5alice = sp.test_account("Alice")
   6bob = sp.test_account("Bob")
   7charlie = sp.test_account("Charlie")
   8
   9
  10def make_metadata(symbol, name, decimals):
  11    """Helper function to build metadata JSON bytes values."""
  12    return sp.map(
  13        l={
  14            "decimals": sp.scenario_utils.bytes_of_string("%d" % decimals),
  15            "name": sp.scenario_utils.bytes_of_string(name),
  16            "symbol": sp.scenario_utils.bytes_of_string(symbol),
  17        }
  18    )
  19
  20
  21tok0_md = make_metadata(name="Token Zero", decimals=1, symbol="Tok0")
  22tok1_md = make_metadata(name="Token One", decimals=1, symbol="Tok1")
  23tok2_md = make_metadata(name="Token Two", decimals=1, symbol="Tok2")
  24
  25
  26@sp.module
  27def helpers():
  28    t_balance_of_response: type = sp.record(
  29        request=sp.record(owner=sp.address, token_id=sp.nat).layout(
  30            ("owner", "token_id")
  31        ),
  32        balance=sp.nat,
  33    ).layout(("request", "balance"))
  34
  35    class TestReceiverBalanceOf(sp.Contract):
  36        """Helper used to test the `balance_of` entrypoint.
  37
  38        Don't use it on-chain as it can be tricked.
  39        """
  40
  41        def __init__(self):
  42            self.data.last_received_balances = []
  43
  44        @sp.entrypoint
  45        def receive_balances(self, params):
  46            sp.cast(params, sp.list[t_balance_of_response])
  47            self.data.last_received_balances = params
  48
  49    class Wallet(sp.Contract):
  50        @sp.entrypoint
  51        def default(self):
  52            pass
  53
  54
  55################################################################################
  56
  57# Standard features tests
  58
  59
  60def _get_balance(fa2, arg):
  61    return sp.View(fa2, "get_balance")(arg)
  62
  63
  64def _get_balance_of(fa2, arg):
  65    return sp.View(fa2, "get_balance_of")(arg)
  66
  67
  68def _total_supply(fa2, arg):
  69    return sp.View(fa2, "total_supply")(arg)
  70
  71
  72def test_core_interfaces(class_, kwargs, ledger_type, test_name="", modules=[]):
  73    """Test that each core interface has the right type and layout.
  74
  75    Args:
  76        test_name (string): Name of the test
  77        fa2 (sp.Contract): The FA2 contract on which the tests occur.
  78
  79    The contract must contains the tokens 0: tok0_md, 1: tok1_md, 2: tok2_md.
  80
  81    For NFT contracts, `alice` must own the three tokens.
  82
  83    For Fungible contracts, `alice` must own 42 of each token types.
  84
  85    Tests:
  86
  87    - Entrypoints: `balance_of`, `transfer`, `update_operators`
  88    - Storage: test of `token_metadata`
  89    """
  90    test_name = "test_core_interfaces_" + ledger_type + "_" + test_name
  91
  92    @sp.add_test()
  93    def test():
  94        sc = sp.test_scenario(test_name, modules)
  95        sc.add_module(helpers)
  96        sc.h1(test_name)
  97        sc.p("A call to all the standard entrypoints and off-chain views.")
  98
  99        sc.h2("Accounts")
 100        sc.show([admin, alice, bob])
 101
 102        sc.h2("FA2 contract")
 103        fa2 = class_(**kwargs)
 104        sc += fa2
 105
 106        # Entrypoints
 107
 108        sc.h2("Entrypoint: update_operators")
 109        fa2.update_operators(
 110            sp.set_type_expr(
 111                [
 112                    sp.variant(
 113                        "add_operator",
 114                        sp.record(
 115                            owner=alice.address, operator=alice.address, token_id=0
 116                        ),
 117                    )
 118                ],
 119                sp.list[
 120                    sp.variant(
 121                        add_operator=sp.record(
 122                            owner=sp.address, operator=sp.address, token_id=sp.nat
 123                        ).layout(("owner", ("operator", "token_id"))),
 124                        remove_operator=sp.record(
 125                            owner=sp.address, operator=sp.address, token_id=sp.nat
 126                        ).layout(("owner", ("operator", "token_id"))),
 127                    )
 128                ],
 129            ),
 130            _sender=alice,
 131        )
 132
 133        sc.h2("Entrypoint: transfer")
 134        fa2.transfer(
 135            sp.set_type_expr(
 136                [
 137                    sp.record(
 138                        from_=alice.address,
 139                        txs=[sp.record(to_=alice.address, amount=1, token_id=0)],
 140                    )
 141                ],
 142                sp.list[
 143                    sp.record(
 144                        from_=sp.address,
 145                        txs=sp.list[
 146                            sp.record(
 147                                to_=sp.address, token_id=sp.nat, amount=sp.nat
 148                            ).layout(("to_", ("token_id", "amount")))
 149                        ],
 150                    ).layout(("from_", "txs"))
 151                ],
 152            ),
 153            _sender=alice,
 154        )
 155
 156        sc.h2("Entrypoint: balance_of")
 157        sc.h3("Receiver contract")
 158        c2 = helpers.TestReceiverBalanceOf()
 159        sc += c2
 160
 161        sc.h3("Call to balance_of")
 162        fa2.balance_of(
 163            sp.set_type_expr(
 164                sp.record(
 165                    callback=sp.contract(
 166                        sp.list[helpers.t_balance_of_response],
 167                        c2.address,
 168                        entrypoint="receive_balances",
 169                    ).unwrap_some(),
 170                    requests=[sp.record(owner=alice.address, token_id=0)],
 171                ),
 172                sp.record(
 173                    requests=sp.list[
 174                        sp.record(owner=sp.address, token_id=sp.nat).layout(
 175                            ("owner", "token_id")
 176                        )
 177                    ],
 178                    callback=sp.contract[
 179                        sp.list[
 180                            sp.record(
 181                                request=sp.record(
 182                                    owner=sp.address, token_id=sp.nat
 183                                ).layout(("owner", "token_id")),
 184                                balance=sp.nat,
 185                            ).layout(("request", "balance"))
 186                        ]
 187                    ],
 188                ).layout(("requests", "callback")),
 189            ),
 190            _sender=alice,
 191        )
 192
 193        # Storage
 194
 195        sc.h2("Storage: token_metadata")
 196        sc.verify_equal(
 197            fa2.data.token_metadata[0], sp.record(token_id=0, token_info=tok0_md)
 198        )
 199
 200
 201def test_transfer(class_, kwargs, ledger_type, test_name="", modules=[]):
 202    """Test that transfer entrypoint works as expected.
 203
 204    Do not test transfer permission policies.
 205
 206    Args:
 207        test_name (string): Name of the test
 208        fa2 (sp.Contract): The FA2 contract on which the tests occur.
 209
 210    SingleAsset contract: The contract must contains the token 0: tok0_md.
 211    Others: The contract must contains the tokens 0: tok0_md, 1: tok1_md, 2: tok2_md.
 212
 213    NFT contract: `sp.test_account("Alice").address` must own all the tokens.
 214    Fungible contract: `sp.test_account("Alice").address` must own 42 of each token.
 215
 216    Tests:
 217        - initial minting works as expected.
 218        - `get_balance` returns `balance = 0` for non owned tokens.
 219        - transfer of 0 tokens works when not owning tokens.
 220        - transfer of 0 doesn't change `ledger` storage.
 221        - transfer of 0 tokens works when owning tokens.
 222        - transfers with multiple operations and transactions works as expected.
 223        - fails with `FA2_INSUFFICIENT_BALANCE` when not enough balance.
 224        - transfer to self doesn't change anything.
 225        - transfer to self with more than balance gives `FA2_INSUFFICIENT_BALANCE`.
 226        - transfer to self of undefined token gives `FA2_TOKEN_UNDEFINED`.
 227        - transfer to someone else of undefined token gives `FA2_TOKEN_UNDEFINED`.
 228    """
 229    test_name = "test_transfer_" + ledger_type + "_" + test_name
 230
 231    @sp.add_test()
 232    def test():
 233        sc = sp.test_scenario(test_name, modules)
 234        sc.h1(test_name)
 235
 236        sc.h2("Accounts")
 237        sc.show([admin, alice, bob])
 238
 239        sc.h2("Contract")
 240        fa2 = class_(**kwargs)
 241        sc += fa2
 242
 243        if ledger_type == "NFT":
 244            ICO = 1  # Initial coin offering.
 245            TX = 1  # How much we transfer at a time during the tests.
 246        else:
 247            ICO = 42  # Initial coin offering.
 248            TX = 12  # How much we transfer at a time during the tests.
 249
 250        # Check that the contract storage is correctly initialized.
 251        sc.verify(_get_balance(fa2, sp.record(owner=alice.address, token_id=0)) == ICO)
 252        if not ledger_type == "SingleAsset":
 253            sc.verify(
 254                _get_balance(fa2, sp.record(owner=alice.address, token_id=1)) == ICO
 255            )
 256            sc.verify(
 257                _get_balance(fa2, sp.record(owner=alice.address, token_id=2)) == ICO
 258            )
 259
 260        # Check that the balance is interpreted as zero when the owner doesn't hold any.
 261        # TZIP-12: If the token owner does not hold any tokens of type token_id,
 262        #          the owner's balance is interpreted as zero.
 263        sc.verify(_get_balance(fa2, sp.record(owner=bob.address, token_id=0)) == 0)
 264
 265        sc.h2("Zero amount transfer")
 266        sc.p("TZIP-12: Transfers of zero amount MUST be treated as normal transfers.")
 267
 268        # Check that someone with 0 token can transfer 0 token.
 269        fa2.transfer(
 270            [
 271                sp.record(
 272                    from_=bob.address,
 273                    txs=[sp.record(to_=alice.address, amount=0, token_id=0)],
 274                ),
 275            ],
 276            _sender=bob,
 277        )
 278
 279        # Check that the contract storage is unchanged.
 280        sc.verify(_get_balance(fa2, sp.record(owner=alice.address, token_id=0)) == ICO)
 281        sc.verify(_get_balance(fa2, sp.record(owner=bob.address, token_id=0)) == 0)
 282
 283        # Check that someone with some tokens can transfer 0 token.
 284        fa2.transfer(
 285            [
 286                sp.record(
 287                    from_=alice.address,
 288                    txs=[sp.record(to_=bob.address, amount=0, token_id=0)],
 289                ),
 290            ],
 291            _sender=alice,
 292        )
 293
 294        # Check that the contract storage is unchanged.
 295        sc.verify(_get_balance(fa2, sp.record(owner=alice.address, token_id=0)) == ICO)
 296        sc.verify(_get_balance(fa2, sp.record(owner=bob.address, token_id=0)) == 0)
 297
 298        sc.h2("Transfers Alice -> Bob")
 299        sc.p(
 300            """TZIP-12: Each transfer in the batch MUST decrement token balance
 301                of the source (from_) address by the amount of the transfer and
 302                increment token balance of the destination (to_) address by the
 303                amount of the transfer."""
 304        )
 305
 306        # Perform a complex transfer with 2 operations, one of which contains 2 transactions.
 307        if ledger_type == "SingleAsset":
 308            fa2.transfer(
 309                [
 310                    sp.record(
 311                        from_=alice.address,
 312                        txs=[
 313                            sp.record(to_=bob.address, amount=TX // 3, token_id=0),
 314                            sp.record(to_=bob.address, amount=TX // 3, token_id=0),
 315                        ],
 316                    ),
 317                    sp.record(
 318                        from_=alice.address,
 319                        txs=[sp.record(to_=bob.address, amount=TX // 3, token_id=0)],
 320                    ),
 321                ],
 322                _sender=alice,
 323            )
 324        else:
 325            fa2.transfer(
 326                [
 327                    sp.record(
 328                        from_=alice.address,
 329                        txs=[
 330                            sp.record(to_=bob.address, amount=TX, token_id=0),
 331                            sp.record(to_=bob.address, amount=TX, token_id=1),
 332                        ],
 333                    ),
 334                    sp.record(
 335                        from_=alice.address,
 336                        txs=[sp.record(to_=bob.address, amount=TX, token_id=2)],
 337                    ),
 338                ],
 339                _sender=alice,
 340            )
 341
 342        # Check that the contract storage is correctly updated.
 343        sc.verify(
 344            _get_balance(fa2, sp.record(owner=alice.address, token_id=0)) == ICO - TX
 345        )
 346        sc.verify(_get_balance(fa2, sp.record(owner=bob.address, token_id=0)) == TX)
 347
 348        if not ledger_type == "SingleAsset":
 349            sc.verify(
 350                _get_balance(fa2, sp.record(owner=alice.address, token_id=1))
 351                == ICO - TX
 352            )
 353            sc.verify(_get_balance(fa2, sp.record(owner=bob.address, token_id=1)) == TX)
 354
 355        # Check without using get_balance because the ledger interface
 356        # differs between NFT and fungible.
 357        if ledger_type == "NFT":
 358            sc.verify(fa2.data.ledger[0] == bob.address)
 359        else:
 360            if ledger_type == "Fungible":
 361                sc.verify(fa2.data.ledger[(alice.address, 0)] == ICO - TX)
 362                sc.verify(fa2.data.ledger[(bob.address, 0)] == TX)
 363            else:
 364                sc.verify(fa2.data.ledger[alice.address] == ICO - TX)
 365                sc.verify(fa2.data.ledger[bob.address] == TX)
 366
 367        # Error tests
 368
 369        # test of FA2_INSUFFICIENT_BALANCE.
 370        sc.h2("Insufficient balance")
 371        sc.p(
 372            """TIP-12: If the transfer amount exceeds current token balance of
 373                the source address, the whole transfer operation MUST fail with
 374                the error mnemonic "FA2_INSUFFICIENT_BALANCE"."""
 375        )
 376
 377        # Compute bob_balance to transfer 1 more token.
 378        bob_balance = sc.compute(
 379            _get_balance(fa2, sp.record(owner=bob.address, token_id=0))
 380        )
 381
 382        # Test that a complex transfer with only one insufficient
 383        # balance fails.
 384        fa2.transfer(
 385            [
 386                sp.record(
 387                    from_=bob.address,
 388                    txs=[
 389                        sp.record(
 390                            to_=alice.address, amount=bob_balance + 1, token_id=0
 391                        ),
 392                        sp.record(to_=alice.address, amount=0, token_id=0),
 393                    ],
 394                ),
 395                sp.record(
 396                    from_=bob.address,
 397                    txs=[sp.record(to_=alice.address, amount=0, token_id=0)],
 398                ),
 399            ],
 400            _sender=bob,
 401            _valid=False,
 402            _exception="FA2_INSUFFICIENT_BALANCE",
 403        )
 404
 405        sc.h2("Same address transfer")
 406        sc.p(
 407            """TZIP-12: Transfers with the same address (from_ equals to_) MUST
 408                be treated as normal transfers."""
 409        )
 410
 411        # Test that someone can transfer all his balance to itself
 412        # without problem.
 413        fa2.transfer(
 414            [
 415                sp.record(
 416                    from_=bob.address,
 417                    txs=[sp.record(to_=bob.address, amount=bob_balance, token_id=0)],
 418                ),
 419            ],
 420            _sender=bob,
 421        )
 422
 423        # Check that the contract storage is unchanged.
 424        sc.verify(
 425            _get_balance(fa2, sp.record(owner=alice.address, token_id=0)) == ICO - TX
 426        )
 427        sc.verify(_get_balance(fa2, sp.record(owner=bob.address, token_id=0)) == TX)
 428        if not ledger_type == "SingleAsset":
 429            sc.verify(
 430                _get_balance(fa2, sp.record(owner=alice.address, token_id=1))
 431                == ICO - TX
 432            )
 433            sc.verify(_get_balance(fa2, sp.record(owner=bob.address, token_id=1)) == TX)
 434
 435        # Test that someone cannot transfer more tokens than he holds
 436        # even to himself.
 437        fa2.transfer(
 438            [
 439                sp.record(
 440                    from_=bob.address,
 441                    txs=[
 442                        sp.record(to_=bob.address, amount=bob_balance + 1, token_id=0)
 443                    ],
 444                ),
 445            ],
 446            _sender=bob,
 447            _valid=False,
 448            _exception="FA2_INSUFFICIENT_BALANCE",
 449        )
 450
 451        # test of FA2_TOKEN_UNDEFINED.
 452        sc.h2("Not defined token")
 453        sc.p(
 454            """TZIP-12: If one of the specified token_ids is not defined within
 455                the FA2 contract, the entrypoint MUST fail with the error
 456                mnemonic "FA2_TOKEN_UNDEFINED"."""
 457        )
 458
 459        # A transfer of 0 tokens to self gives FA2_TOKEN_UNDEFINED if
 460        # not defined.
 461        fa2.transfer(
 462            [
 463                sp.record(
 464                    from_=bob.address,
 465                    txs=[sp.record(to_=bob.address, amount=0, token_id=4)],
 466                ),
 467            ],
 468            _sender=bob,
 469            _valid=False,
 470            _exception="FA2_TOKEN_UNDEFINED",
 471        )
 472
 473        # A transfer of 1 token to someone else gives
 474        # FA2_TOKEN_UNDEFINED if not defined.
 475        fa2.transfer(
 476            [
 477                sp.record(
 478                    from_=alice.address,
 479                    txs=[sp.record(to_=bob.address, amount=1, token_id=4)],
 480                ),
 481            ],
 482            _sender=bob,
 483            _valid=False,
 484            _exception="FA2_TOKEN_UNDEFINED",
 485        )
 486
 487
 488def test_balance_of(class_, kwargs, ledger_type, test_name="", modules=[]):
 489    """Test that balance_of entrypoint works as expected.
 490
 491    Args:
 492        test_name (string): Name of the test
 493        fa2 (sp.Contract): The FA2 contract on which the tests occur.
 494
 495    SingleAsset contract: The contract must contains the token 0: tok0_md.
 496    Others: The contract must contains the tokens 0: tok0_md, 1: tok1_md, 2: tok2_md.
 497
 498    NFT contract: `sp.test_account("Alice").address` must own all the tokens.
 499    Fungible contract: `sp.test_account("Alice").address` must own 42 of each token.
 500
 501    Tests:
 502
 503    - `balance_of` calls back with valid results.
 504    - `balance_of` fails with `FA2_TOKEN_UNDEFINED` when token is undefined.
 505    """
 506    test_name = "test_balance_of_" + ledger_type + "_" + test_name
 507
 508    @sp.add_test()
 509    def test():
 510        sc = sp.test_scenario(test_name, modules)
 511        sc.add_module(helpers)
 512        sc.h1(test_name)
 513
 514        sc.h2("Accounts")
 515        sc.show([admin, alice, bob])
 516
 517        # We initialize the contract with an initial mint.
 518        sc.h2("Contract")
 519        fa2 = class_(**kwargs)
 520        sc += fa2
 521
 522        sc.h3("Receiver contract")
 523        c2 = helpers.TestReceiverBalanceOf()
 524        sc += c2
 525
 526        ICO = 1 if ledger_type == "NFT" else 42  # Initial coin offering.
 527        last_token_id = 0 if ledger_type == "SingleAsset" else 2
 528
 529        requests = [
 530            sp.record(owner=alice.address, token_id=0),
 531            sp.record(owner=alice.address, token_id=0),
 532            sp.record(owner=bob.address, token_id=0),
 533            sp.record(owner=alice.address, token_id=last_token_id),
 534        ]
 535        expected = [
 536            sp.record(balance=ICO, request=sp.record(owner=alice.address, token_id=0)),
 537            sp.record(balance=ICO, request=sp.record(owner=alice.address, token_id=0)),
 538            sp.record(balance=0, request=sp.record(owner=bob.address, token_id=0)),
 539            sp.record(
 540                balance=ICO,
 541                request=sp.record(owner=alice.address, token_id=last_token_id),
 542            ),
 543        ]
 544
 545        # Call to balance_of.
 546        fa2.balance_of(
 547            callback=sp.contract(
 548                sp.list[helpers.t_balance_of_response],
 549                c2.address,
 550                entrypoint="receive_balances",
 551            ).unwrap_some(),
 552            requests=requests,
 553            _sender=alice,
 554        )
 555
 556        # Check that balance_of returns the correct balances.
 557        # This test non-deduplication, non-reordering, on multiple tokens.
 558        sc.verify_equal(c2.data.last_received_balances, expected)
 559
 560        # Expected errors
 561        sc.h2("FA2_TOKEN_UNDEFINED error")
 562        fa2.balance_of(
 563            callback=sp.contract(
 564                sp.list[helpers.t_balance_of_response],
 565                c2.address,
 566                entrypoint="receive_balances",
 567            ).unwrap_some(),
 568            requests=[
 569                sp.record(owner=alice.address, token_id=0),
 570                sp.record(owner=alice.address, token_id=5),
 571            ],
 572            _sender=alice,
 573            _valid=False,
 574            _exception="FA2_TOKEN_UNDEFINED",
 575        )
 576
 577
 578def test_no_transfer(class_, kwargs, ledger_type, test_name="", modules=[]):
 579    """Test that the `no-transfer` policy works as expected.
 580
 581    Args:
 582        test_name (string): Name of the test
 583        fa2 (sp.Contract): The FA2 contract on which the tests occur.
 584
 585    The contract must contains the tokens 0: tok0_md, 1: tok1_md, 2: tok2_md.
 586
 587    For NFT contracts, `alice` must own the three tokens.
 588
 589    For Fungible contracts, `alice` must own 42 of each token types.
 590
 591    Tests:
 592
 593    - transfer fails with FA2_TX_DENIED.
 594    - transfer fails with FA2_TX_DENIED even for admin.
 595    - update_operators fails with FA2_OPERATORS_UNSUPPORTED.
 596    """
 597    test_name = "test_no-transfer_" + ledger_type + "_" + test_name
 598
 599    @sp.add_test()
 600    def test():
 601        sc = sp.test_scenario(test_name, modules)
 602        sc.h1(test_name)
 603
 604        sc.h2("Accounts")
 605        sc.show([admin, alice, bob])
 606
 607        sc.h2("FA2 with NoTransfer policy")
 608        sc.p("No transfer are allowed.")
 609        fa2 = class_(**kwargs)
 610        sc += fa2
 611
 612        # Transfer fails as expected.
 613        sc.h2("Alice cannot transfer: FA2_TX_DENIED")
 614        fa2.transfer(
 615            [
 616                sp.record(
 617                    from_=alice.address,
 618                    txs=[sp.record(to_=bob.address, amount=1, token_id=0)],
 619                )
 620            ],
 621            _sender=alice,
 622            _valid=False,
 623            _exception="FA2_TX_DENIED",
 624        )
 625
 626        # Even Admin cannot transfer.
 627        sc.h2("Admin cannot transfer alice's token: FA2_TX_DENIED")
 628        fa2.transfer(
 629            [
 630                sp.record(
 631                    from_=alice.address,
 632                    txs=[sp.record(to_=alice.address, amount=1, token_id=0)],
 633                )
 634            ],
 635            _sender=admin,
 636            _valid=False,
 637            _exception="FA2_TX_DENIED",
 638        )
 639
 640        # update_operators is unsupported.
 641        sc.h2("Alice cannot add operator: FA2_OPERATORS_UNSUPPORTED")
 642        fa2.update_operators(
 643            [
 644                sp.variant(
 645                    "add_operator",
 646                    sp.record(owner=alice.address, operator=bob.address, token_id=0),
 647                )
 648            ],
 649            _sender=alice,
 650            _valid=False,
 651            _exception="FA2_OPERATORS_UNSUPPORTED",
 652        )
 653
 654
 655def test_owner_transfer(class_, kwargs, ledger_type, test_name="", modules=[]):
 656    """Test that the `owner-transfer` policy works as expected.
 657
 658    Args:
 659        test_name (string): Name of the test
 660        fa2 (sp.Contract): the FA2 contract on which the tests occur.
 661
 662    The contract must contains the tokens 0: tok0_md, 1: tok1_md, 2: tok2_md.
 663
 664    For NFT contracts, `alice` must own the three tokens.
 665
 666    For Fungible contracts, `alice` must own 42 of each token types.
 667
 668    Tests:
 669
 670    - owner can transfer.
 671    - transfer fails with FA2_NOT_OWNER for non owner, even admin.
 672    - update_operators fails with FA2_OPERATORS_UNSUPPORTED.
 673    """
 674    test_name = "test_owner-transfer_" + ledger_type + "_" + test_name
 675
 676    @sp.add_test()
 677    def test():
 678        sc = sp.test_scenario(test_name, modules)
 679        sc.h1(test_name)
 680
 681        sc.h2("Accounts")
 682        sc.show([admin, alice, bob])
 683
 684        sc.h2("FA2 with OwnerTransfer policy")
 685        sc.p("Only owner can transfer, no operator allowed.")
 686        fa2 = class_(**kwargs)
 687        sc += fa2
 688
 689        # The owner can transfer its tokens.
 690        sc.h2("Alice can transfer")
 691        fa2.transfer(
 692            [
 693                sp.record(
 694                    from_=alice.address,
 695                    txs=[sp.record(to_=alice.address, amount=1, token_id=0)],
 696                )
 697            ],
 698            _sender=alice,
 699        )
 700
 701        # Admin cannot transfer someone else tokens.
 702        sc.h2("Admin cannot transfer alice's token: FA2_NOT_OWNER")
 703        fa2.transfer(
 704            [
 705                sp.record(
 706                    from_=alice.address,
 707                    txs=[sp.record(to_=alice.address, amount=1, token_id=0)],
 708                )
 709            ],
 710            _sender=admin,
 711            _valid=False,
 712            _exception="FA2_NOT_OWNER",
 713        )
 714
 715        # Someone cannot transfer someone else tokens.
 716        sc.h2("Admin cannot transfer alice's token: FA2_NOT_OWNER")
 717        fa2.transfer(
 718            [
 719                sp.record(
 720                    from_=alice.address,
 721                    txs=[sp.record(to_=alice.address, amount=1, token_id=0)],
 722                )
 723            ],
 724            _sender=bob,
 725            _valid=False,
 726            _exception="FA2_NOT_OWNER",
 727        )
 728
 729        # Someone cannot add operator.
 730        sc.h2("Alice cannot add operator: FA2_OPERATORS_UNSUPPORTED")
 731        fa2.update_operators(
 732            [
 733                sp.variant(
 734                    "add_operator",
 735                    sp.record(owner=alice.address, operator=bob.address, token_id=0),
 736                )
 737            ],
 738            _sender=alice,
 739            _valid=False,
 740            _exception="FA2_OPERATORS_UNSUPPORTED",
 741        )
 742
 743
 744def test_owner_or_operator_transfer(
 745    class_, kwargs, ledger_type, test_name="", modules=[]
 746):
 747    """Test that the `owner-or-operator-transfer` policy works as expected.
 748
 749    Args:
 750        test_name (string): Name of the test
 751        fa2 (sp.Contract): The FA2 contract on which the tests occur.
 752
 753    SingleAsset contract: The contract must contains the token 0: tok0_md.
 754    Others: The contract must contains the tokens 0: tok0_md, 1: tok1_md, 2: tok2_md.
 755
 756    NFT contract: `sp.test_account("Alice").address` must own all the tokens.
 757    Fungible contract: `sp.test_account("Alice").address` must own 42 of each token.
 758
 759    Tests:
 760
 761    - owner can transfer.
 762    - transfer fails with FA2_NOT_OPERATOR for non operator, even admin.
 763    - update_operators fails with FA2_OPERATORS_UNSUPPORTED.
 764    - owner can add operator.
 765    - operator can transfer.
 766    - operator cannot transfer for non allowed `token_id`.
 767    - owner can remove operator and add operator in a batch.
 768    - removed operator cannot transfer anymore.
 769    - operator added in a batch can transfer.
 770    - add then remove the same operator doesn't change the storage.
 771    - remove then add the same operator does change the storage.
 772    """
 773    test_name = "test_owner-or-operator-transfer_" + ledger_type + "_" + test_name
 774
 775    @sp.add_test()
 776    def test():
 777        operator_bob = sp.record(owner=alice.address, operator=bob.address, token_id=0)
 778        operator_charlie = sp.record(
 779            owner=alice.address, operator=charlie.address, token_id=0
 780        )
 781
 782        sc = sp.test_scenario(test_name, modules)
 783        sc.h1(test_name)
 784
 785        sc.h2("Accounts")
 786        sc.show([admin, alice, bob])
 787
 788        sc.h2("FA2 with OwnerOrOperatorTransfer policy")
 789        sc.p("Owner or operators can transfer.")
 790        fa2 = class_(**kwargs)
 791        sc += fa2
 792
 793        # Owner can transfer his tokens.
 794        sc.h2("Alice can transfer")
 795        fa2.transfer(
 796            [
 797                sp.record(
 798                    from_=alice.address,
 799                    txs=[sp.record(to_=alice.address, amount=1, token_id=0)],
 800                )
 801            ],
 802            _sender=alice,
 803        )
 804
 805        # Admin can transfer others tokens.
 806        sc.h2("Admin cannot transfer alice's token: FA2_NOT_OPERATOR")
 807        fa2.transfer(
 808            [
 809                sp.record(
 810                    from_=alice.address,
 811                    txs=[sp.record(to_=alice.address, amount=1, token_id=0)],
 812                )
 813            ],
 814            _sender=admin,
 815            _valid=False,
 816            _exception="FA2_NOT_OPERATOR",
 817        )
 818
 819        # Update operator works.
 820        sc.h2("Alice adds Bob as operator")
 821        fa2.update_operators([sp.variant.add_operator(operator_bob)], _sender=alice)
 822
 823        # The contract is updated as expected.
 824        sc.verify(fa2.data.operators.contains(operator_bob))
 825
 826        # Operator can transfer allowed tokens on behalf of owner.
 827        sc.h2("Bob can transfer Alice's token id 0")
 828        fa2.transfer(
 829            [
 830                sp.record(
 831                    from_=alice.address,
 832                    txs=[sp.record(to_=alice.address, amount=1, token_id=0)],
 833                )
 834            ],
 835            _sender=bob,
 836        )
 837
 838        if not ledger_type == "SingleAsset":
 839            # Operator cannot transfer not allowed tokens on behalf of owner.
 840            sc.h2("Bob cannot transfer Alice's token id 1")
 841            fa2.transfer(
 842                [
 843                    sp.record(
 844                        from_=alice.address,
 845                        txs=[sp.record(to_=alice.address, amount=1, token_id=1)],
 846                    )
 847                ],
 848                _sender=bob,
 849                _valid=False,
 850                _exception="FA2_NOT_OPERATOR",
 851            )
 852
 853        # Batch of update_operators actions.
 854        sc.h2("Alice can remove Bob as operator and add Charlie")
 855        fa2.update_operators(
 856            [
 857                sp.variant.remove_operator(operator_bob),
 858                sp.variant.add_operator(operator_charlie),
 859            ],
 860            _sender=alice,
 861        )
 862
 863        # The contract is updated as expected.
 864        sc.verify(~fa2.data.operators.contains(operator_bob))
 865        sc.verify(fa2.data.operators.contains(operator_charlie))
 866
 867        # A removed operator lose its rights.
 868        sc.h2("Bob cannot transfer Alice's token 0 anymore")
 869        fa2.transfer(
 870            [
 871                sp.record(
 872                    from_=alice.address,
 873                    txs=[sp.record(to_=alice.address, amount=1, token_id=0)],
 874                )
 875            ],
 876            _sender=bob,
 877            _valid=False,
 878            _exception="FA2_NOT_OPERATOR",
 879        )
 880
 881        # The new added operator can now do the transfer.
 882        sc.h2("Charlie can transfer Alice's token")
 883        fa2.transfer(
 884            [
 885                sp.record(
 886                    from_=alice.address,
 887                    txs=[sp.record(to_=charlie.address, amount=1, token_id=0)],
 888                )
 889            ],
 890            _sender=charlie,
 891        )
 892
 893        # The contract is updated as expected.
 894        sc.verify(_get_balance(fa2, sp.record(owner=charlie.address, token_id=0)) == 1)
 895
 896        # Remove after a Add does nothing.
 897        sc.h2("Add then Remove in the same batch is transparent")
 898        sc.p(
 899            """TZIP-12: If two different commands in the list add and remove an
 900                operator for the same token owner and token ID, the last command
 901                in the list MUST take effect."""
 902        )
 903        fa2.update_operators(
 904            [
 905                sp.variant.add_operator(operator_bob),
 906                sp.variant.remove_operator(operator_bob),
 907            ],
 908            _sender=alice,
 909        )
 910        sc.verify(~fa2.data.operators.contains(operator_bob))
 911
 912        # Add after remove works
 913        sc.h2("Remove then Add do add the operator")
 914        fa2.update_operators(
 915            [
 916                sp.variant.remove_operator(operator_bob),
 917                sp.variant.add_operator(operator_bob),
 918            ],
 919            _sender=alice,
 920        )
 921        sc.verify(fa2.data.operators.contains(operator_bob))
 922
 923
 924################################################################################
 925
 926# Optional features tests
 927
 928
 929class NS:
 930    """Non standard features of FA2_lib
 931
 932    Mixin tested:
 933
 934    - Admin,
 935    - WithdrawMutez
 936    - ChangeMetadata
 937    - OffchainviewTokenMetadata
 938    - OnchainviewBalanceOf
 939    - Mint*
 940    - Burn*
 941    """
 942
 943    def test_admin(class_, kwargs, ledger_type, test_name="", modules=[]):
 944        """Test `Admin` mixin
 945
 946        - non admin cannot set admin
 947        - admin can set admin
 948        - new admin can set admin
 949        """
 950        test_name = "FA2_optional_interfaces_admin" + ledger_type + test_name
 951
 952        @sp.add_test()
 953        def test():
 954            sc = sp.test_scenario(test_name, modules)
 955            fa2 = class_(**kwargs)
 956            sc += fa2
 957            sc.h1(test_name)
 958            sc.h2("Non admin cannot set admin")
 959            fa2.set_administrator(
 960                alice.address, _sender=alice, _valid=False, _exception="FA2_NOT_ADMIN"
 961            )
 962            sc.verify(fa2.data.administrator == admin.address)
 963            fa2.set_administrator(admin2.address, _sender=admin)
 964            sc.verify(~(fa2.data.administrator == admin.address))
 965            sc.verify(fa2.data.administrator == admin2.address)
 966            fa2.set_administrator(admin.address, _sender=admin2)
 967
 968    def test_mint(class_, kwargs, ledger_type, test_name="", modules=[]):
 969        """Test `Mint*` mixin.
 970
 971        - `mint` fails with `FA2_NOT_ADMIN` for non-admin.
 972        - `mint` adds the tokens.
 973        - `mint` update the supply.
 974        - `mint` works for existing tokens in fungible contracts.
 975        """
 976        test_name = "FA2_mint_" + ledger_type + test_name
 977
 978        def mint_nft(sc, fa2):
 979            sc.h2("Mint entrypoint")
 980            # Non admin cannot mint a new NFT token.
 981            sc.h3("NFT mint failure")
 982            fa2.mint(
 983                [sp.record(metadata=tok0_md, to_=alice.address)],
 984                _sender=alice,
 985                _valid=False,
 986                _exception="FA2_NOT_ADMIN",
 987            )
 988
 989            sc.h3("Mint")
 990            # Mint of a new NFT token.
 991            fa2.mint(
 992                [
 993                    sp.record(metadata=tok0_md, to_=alice.address),
 994                    sp.record(metadata=tok1_md, to_=alice.address),
 995                    sp.record(metadata=tok2_md, to_=bob.address),
 996                ],
 997                _sender=admin,
 998            )
 999
1000            # Check that the balance is updated.
1001            sc.verify(
1002                _get_balance(fa2, sp.record(owner=alice.address, token_id=0)) == 1
1003            )
1004            sc.verify(_get_balance(fa2, sp.record(owner=bob.address, token_id=0)) == 0)
1005            sc.verify(
1006                _get_balance(fa2, sp.record(owner=alice.address, token_id=1)) == 1
1007            )
1008            sc.verify(_get_balance(fa2, sp.record(owner=bob.address, token_id=1)) == 0)
1009            sc.verify(
1010                _get_balance(fa2, sp.record(owner=alice.address, token_id=2)) == 0
1011            )
1012            sc.verify(_get_balance(fa2, sp.record(owner=bob.address, token_id=2)) == 1)
1013
1014            # Check that the supply is updated.
1015            sc.verify(_total_supply(fa2, sp.record(token_id=0)) == 1)
1016            sc.verify(_total_supply(fa2, sp.record(token_id=1)) == 1)
1017            sc.verify(_total_supply(fa2, sp.record(token_id=2)) == 1)
1018
1019        def mint_fungible(sc, fa2):
1020            sc.h2("Mint entrypoint")
1021            # Non admin cannot mint a new fungible token.
1022            sc.h3("Fungible mint failure")
1023            fa2.mint(
1024                [
1025                    sp.record(
1026                        token=sp.variant.new(tok0_md), to_=alice.address, amount=1000
1027                    )
1028                ],
1029                _sender=alice,
1030                _valid=False,
1031                _exception="FA2_NOT_ADMIN",
1032            )
1033
1034            sc.h3("Mint")
1035            # Mint of a new fungible token.
1036            fa2.mint(
1037                [
1038                    sp.record(
1039                        token=sp.variant.new(tok0_md), to_=alice.address, amount=1000
1040                    )
1041                ],
1042                _sender=admin,
1043            )
1044
1045            # Check ledger update.
1046            sc.verify(
1047                _get_balance(fa2, sp.record(owner=alice.address, token_id=0)) == 1000
1048            )
1049            sc.verify(_get_balance(fa2, sp.record(owner=bob.address, token_id=0)) == 0)
1050            # Check supply update.
1051            sc.verify(_total_supply(fa2, sp.record(token_id=0)) == 1000)
1052
1053            # Mint a new and existing token.
1054            fa2.mint(
1055                [
1056                    sp.record(
1057                        token=sp.variant.new(tok1_md), to_=alice.address, amount=1000
1058                    ),
1059                    sp.record(
1060                        token=sp.variant.existing(0), to_=alice.address, amount=1000
1061                    ),
1062                    sp.record(
1063                        token=sp.variant.existing(1), to_=bob.address, amount=1000
1064                    ),
1065                ],
1066                _sender=admin,
1067            )
1068
1069            # Check ledger update.
1070            sc.verify(
1071                _get_balance(fa2, sp.record(owner=alice.address, token_id=0)) == 2000
1072            )
1073            sc.verify(_get_balance(fa2, sp.record(owner=bob.address, token_id=0)) == 0)
1074            sc.verify(
1075                _get_balance(fa2, sp.record(owner=alice.address, token_id=1)) == 1000
1076            )
1077            sc.verify(
1078                _get_balance(fa2, sp.record(owner=bob.address, token_id=1)) == 1000
1079            )
1080            # Check supply update.
1081            sc.verify(_total_supply(fa2, sp.record(token_id=0)) == 2000)
1082            sc.verify(_total_supply(fa2, sp.record(token_id=1)) == 2000)
1083
1084        def mint_single_asset(sc, fa2):
1085            sc.h2("Mint entrypoint")
1086            # Non admin cannot mint a new fungible token.
1087            sc.h3("Single asset mint failure")
1088            fa2.mint(
1089                [sp.record(to_=alice.address, amount=1000)],
1090                _sender=alice,
1091                _valid=False,
1092                _exception="FA2_NOT_ADMIN",
1093            )
1094
1095            sc.h3("Mint")
1096            # Mint some tokens
1097            fa2.mint([sp.record(to_=alice.address, amount=1000)], _sender=admin)
1098
1099            # Check ledger update.
1100            sc.verify(
1101                _get_balance(fa2, sp.record(owner=alice.address, token_id=0)) == 1000
1102            )
1103            sc.verify(_get_balance(fa2, sp.record(owner=bob.address, token_id=0)) == 0)
1104            # Check supply update.
1105            sc.verify(_total_supply(fa2, sp.record(token_id=0)) == 1000)
1106
1107            # multiple mint
1108            fa2.mint(
1109                [
1110                    sp.record(to_=alice.address, amount=1000),
1111                    sp.record(to_=bob.address, amount=1000),
1112                    sp.record(to_=bob.address, amount=1000),
1113                ],
1114                _sender=admin,
1115            )
1116
1117            # Check ledger update.
1118            sc.verify(
1119                _get_balance(fa2, sp.record(owner=alice.address, token_id=0)) == 2000
1120            )
1121            sc.verify(
1122                _get_balance(fa2, sp.record(owner=bob.address, token_id=0)) == 2000
1123            )
1124            # Check supply update.
1125            sc.verify(_total_supply(fa2, sp.record(token_id=0)) == 4000)
1126
1127        @sp.add_test()
1128        def test():
1129            sc = sp.test_scenario(test_name, modules)
1130            fa2 = class_(**kwargs)
1131            sc += fa2
1132            sc.h1(test_name)
1133            if ledger_type == "NFT":
1134                mint_nft(sc, fa2)
1135            elif ledger_type == "Fungible":
1136                mint_fungible(sc, fa2)
1137            elif ledger_type == "SingleAsset":
1138                mint_single_asset(sc, fa2)
1139            else:
1140                raise Exception(
1141                    'fa2.ledger type must be "NFT", "Fungible" or "SingleAsset".'
1142                )
1143
1144    def test_burn(
1145        class_,
1146        kwargs,
1147        ledger_type,
1148        supports_transfer,
1149        supports_operator,
1150        modules=[],
1151        test_name="",
1152    ):
1153        """Test `Burn*` mixin.
1154
1155        - non operator cannot burn, it fails appropriately.
1156        - owner can burn.
1157        - burn fails with `FA2_INSUFFICIENT_BALANCE` when needed.
1158        - operator can burn if the policy allows it.
1159        """
1160        test_name = "FA2_burn_" + ledger_type + test_name
1161
1162        @sp.add_test()
1163        def test():
1164            amount = 1 if ledger_type == "NFT" else 20
1165            sc = sp.test_scenario(test_name, modules)
1166            fa2 = class_(**kwargs)
1167            sc += fa2
1168            sc.h1(test_name)
1169            sc.h2("Burn entrypoint")
1170
1171            # Check that non operator cannot burn others tokens.
1172            sc.h3("Cannot burn others tokens")
1173            exception = "FA2_NOT_OPERATOR" if supports_transfer else "FA2_TX_DENIED"
1174            fa2.burn(
1175                [sp.record(token_id=0, from_=alice.address, amount=1)],
1176                _sender=bob,
1177                _valid=False,
1178                _exception=exception,
1179            )
1180
1181            # Not allowed transfers
1182            if not supports_transfer:
1183                fa2.burn(
1184                    [sp.record(token_id=0, from_=alice.address, amount=amount)],
1185                    _sender=alice,
1186                    _valid=False,
1187                    _exception="FA2_TX_DENIED",
1188                )
1189                return
1190
1191            # Owner can burn.
1192            sc.h3("Owner burns his nft tokens")
1193            fa2.burn(
1194                [sp.record(token_id=0, from_=alice.address, amount=amount)],
1195                _sender=alice,
1196            )
1197
1198            if ledger_type == "NFT":
1199                # Check that the contract storage is updated.
1200                sc.verify(~fa2.data.ledger.contains(0))
1201                # Check that burning an nft removes token_metadata.
1202                sc.verify(~fa2.data.token_metadata.contains(0))
1203            else:
1204                # Check ledger update.
1205                sc.verify(
1206                    _get_balance(fa2, sp.record(owner=alice.address, token_id=0)) == 22
1207                )
1208                # Check that burning doesn't remove token_metadata.
1209                sc.verify(fa2.data.token_metadata.contains(0))
1210                # Check supply update.
1211                sc.verify(_total_supply(fa2, sp.record(token_id=0)) == 22)
1212
1213            # Check burn of FA2_INSUFFICIENT_BALANCE.
1214            sc.h3("Burn with insufficient balance")
1215            token_id = 0 if ledger_type == "SingleAsset" else 1
1216            fa2.burn(
1217                [sp.record(token_id=token_id, from_=alice.address, amount=43)],
1218                _sender=alice,
1219                _valid=False,
1220                _exception="FA2_INSUFFICIENT_BALANCE",
1221            )
1222
1223            if supports_operator:
1224                # Add operator to test if he can burn on behalf of the owner.
1225                sc.h3("Operator can burn on behalf of the owner")
1226                operator_bob = sp.record(
1227                    owner=alice.address, operator=bob.address, token_id=token_id
1228                )
1229                fa2.update_operators(
1230                    [sp.variant.add_operator(operator_bob)], _sender=alice
1231                )
1232                # Operator can burn nft on behalf of the owner.
1233                fa2.burn(
1234                    [sp.record(token_id=token_id, from_=alice.address, amount=0)],
1235                    _sender=bob,
1236                )
1237
1238    def test_withdraw_mutez(class_, kwargs, ledger_type, test_name="", modules=[]):
1239        """Test of WithdrawMutez.
1240
1241        - non admin cannot withdraw mutez: FA2_NOT_ADMIN.
1242        - admin can withdraw mutez.
1243        """
1244        test_name = "FA2_withdraw_mutez" + ledger_type + test_name
1245
1246        @sp.add_test()
1247        def test():
1248            sc = sp.test_scenario(test_name, modules)
1249            sc.add_module(helpers)
1250            fa2 = class_(**kwargs)
1251            sc += fa2
1252            sc.h1(test_name)
1253            sc.h2("Mutez receiver contract")
1254
1255            wallet = helpers.Wallet()
1256            sc += wallet
1257
1258            # Non admin cannot withdraw mutez.
1259            sc.h2("Non admin cannot withdraw_mutez")
1260            fa2.withdraw_mutez(
1261                destination=wallet.address,
1262                amount=sp.tez(10),
1263                _sender=alice,
1264                _amount=sp.tez(42),
1265                _valid=False,
1266                _exception="FA2_NOT_ADMIN",
1267            )
1268
1269            # Admin can withdraw mutez.
1270            sc.h3("Admin withdraw_mutez")
1271            fa2.withdraw_mutez(
1272                destination=wallet.address,
1273                amount=sp.tez(10),
1274                _sender=admin,
1275                _amount=sp.tez(42),
1276            )
1277
1278            # Check that the mutez has been transferred.
1279            sc.verify(fa2.balance == sp.tez(32))
1280            sc.verify(wallet.balance == sp.tez(10))
1281
1282    def test_change_metadata(class_, kwargs, ledger_type, test_name="", modules=[]):
1283        """Test of ChangeMetadata.
1284
1285        - non admin cannot set metadata
1286        - `set_metadata` works as expected
1287        """
1288        test_name = "FA2_change_metadata" + ledger_type + test_name
1289
1290        @sp.add_test()
1291        def test():
1292            sc = sp.test_scenario(test_name, modules)
1293            fa2 = class_(**kwargs)
1294            sc += fa2
1295            sc.h1(test_name)
1296            sc.h2("Change metadata")
1297            sc.h3("Non admin cannot set metadata")
1298            fa2.set_metadata(
1299                sp.scenario_utils.metadata_of_url("http://example.com"),
1300                _sender=alice,
1301                _valid=False,
1302                _exception="FA2_NOT_ADMIN",
1303            )
1304
1305            sc.h3("Admin set metadata")
1306            fa2.set_metadata(
1307                sp.scenario_utils.metadata_of_url("http://example.com"), _sender=admin
1308            )
1309
1310            # Check that the metadata has been updated.
1311            sc.verify_equal(
1312                fa2.data.metadata[""],
1313                sp.scenario_utils.metadata_of_url("http://example.com")[""],
1314            )
1315
1316    def test_get_balance_of(class_, kwargs, ledger_type, test_name="", modules=[]):
1317        """Test of `OnchainviewBalanceOf`
1318
1319        - `get_balance_of` doesn't deduplicate nor reorder on nft.
1320        - `get_balance_of` doesn't deduplicate nor reorder on fungible.
1321        - `get_balance_of` fails with `FA2_TOKEN_UNDEFINED` when needed on nft.
1322        - `get_balance_of` fails with `FA2_TOKEN_UNDEFINED` when needed on fungible.
1323        """
1324        test_name = "FA2_get_balance_of" + ledger_type + test_name
1325
1326        @sp.add_test()
1327        def test():
1328            sc = sp.test_scenario(test_name, modules)
1329            fa2 = class_(**kwargs)
1330            sc += fa2
1331            sc.h1(test_name)
1332
1333            # get_balance_of on fungible
1334            # We deliberately give multiple identical params to check for
1335            # non-deduplication and non-reordering.
1336
1337            ICO = 1 if ledger_type == "NFT" else 42  # Initial coin offering.
1338            last_token_id = 0 if ledger_type == "SingleAsset" else 2
1339
1340            requests = [
1341                sp.record(owner=alice.address, token_id=0),
1342                sp.record(owner=alice.address, token_id=0),
1343                sp.record(owner=bob.address, token_id=0),
1344                sp.record(owner=alice.address, token_id=last_token_id),
1345            ]
1346            expected = [
1347                sp.record(
1348                    balance=ICO, request=sp.record(owner=alice.address, token_id=0)
1349                ),
1350                sp.record(
1351                    balance=ICO, request=sp.record(owner=alice.address, token_id=0)
1352                ),
1353                sp.record(balance=0, request=sp.record(owner=bob.address, token_id=0)),
1354                sp.record(
1355                    balance=ICO,
1356                    request=sp.record(owner=alice.address, token_id=last_token_id),
1357                ),
1358            ]
1359
1360            sc.verify_equal(_get_balance_of(fa2, requests), expected)
1361
1362            # Check that on-chain view fails on undefined tokens.
1363            sc.verify(
1364                sp.catch_exception(
1365                    _get_balance_of(fa2, [sp.record(owner=alice.address, token_id=5)])
1366                )
1367                == sp.Some("FA2_TOKEN_UNDEFINED")
1368            )
1369
1370    def test_offchain_token_metadata(
1371        class_, kwargs, ledger_type, test_name="", modules=[]
1372    ):
1373        """Test `OffchainviewTokenMetadata`.
1374
1375        Tests:
1376
1377        - `token_metadata` works as expected on nft and fungible.
1378        """
1379        test_name = "FA2_offchain_token_metadata" + ledger_type + test_name
1380
1381        @sp.add_test()
1382        def test():
1383            sc = sp.test_scenario(test_name, modules)
1384            fa2 = class_(**kwargs)
1385            sc += fa2
1386            sc.h1(test_name)
1387            sc.verify_equal(
1388                fa2.token_metadata(0), sp.record(token_id=0, token_info=tok0_md)
1389            )
1390
1391    def test_pause(class_, kwargs, ledger_type, test_name="", modules=[]):
1392        """Test the `Pause` policy decorator.
1393
1394        - transfer works without pause
1395        - transfer update_operators without pause
1396        - non admin cannot set_pause
1397        - admin can set pause
1398        - transfer fails with ('FA2_TX_DENIED', 'FA2_PAUSED') when paused.
1399        - update_operators fails with
1400        ('FA2_OPERATORS_UNSUPPORTED', 'FA2_PAUSED') when paused.
1401        """
1402        test_name = "FA2_pause_" + ledger_type + test_name
1403
1404        @sp.add_test()
1405        def test():
1406            sc = sp.test_scenario(test_name, modules)
1407            fa2 = class_(**kwargs)
1408            sc.h1(test_name)
1409
1410            sc.h2("Accounts")
1411            sc.show([admin, alice, bob])
1412            sc.h2("FA2 Contract")
1413            sc += fa2
1414
1415            sc.h2("Transfer without pause")
1416            fa2.transfer(
1417                [
1418                    sp.record(
1419                        from_=alice.address,
1420                        txs=[sp.record(to_=alice.address, amount=0, token_id=0)],
1421                    ),
1422                ],
1423                _sender=alice,
1424            )
1425
1426            sc.h2("Update_operator without pause")
1427            fa2.update_operators(
1428                [
1429                    sp.variant(
1430                        "add_operator",
1431                        sp.record(
1432                            owner=alice.address, operator=alice.address, token_id=0
1433                        ),
1434                    ),
1435                    sp.variant(
1436                        "remove_operator",
1437                        sp.record(
1438                            owner=alice.address, operator=alice.address, token_id=0
1439                        ),
1440                    ),
1441                ],
1442                _sender=alice,
1443            )
1444
1445            sc.h2("Pause entrypoint")
1446            sc.h3("Non admin cannot set pause")
1447            fa2.set_pause(True, _sender=alice, _valid=False, _exception="FA2_NOT_ADMIN")
1448
1449            sc.h3("Admin set pause")
1450            fa2.set_pause(True, _sender=admin)
1451
1452            sc.h2("Transfer fails with pause")
1453            fa2.transfer(
1454                [
1455                    sp.record(
1456                        from_=alice.address,
1457                        txs=[sp.record(to_=alice.address, amount=0, token_id=0)],
1458                    ),
1459                ],
1460                _sender=alice,
1461                _valid=False,
1462                _exception=("FA2_TX_DENIED", "FA2_PAUSED"),
1463            )
1464
1465            sc.h2("Update_operator fails with pause")
1466            fa2.update_operators(
1467                [
1468                    sp.variant(
1469                        "add_operator",
1470                        sp.record(
1471                            owner=alice.address, operator=alice.address, token_id=0
1472                        ),
1473                    ),
1474                    sp.variant(
1475                        "remove_operator",
1476                        sp.record(
1477                            owner=alice.address, operator=alice.address, token_id=0
1478                        ),
1479                    ),
1480                ],
1481                _sender=alice,
1482                _valid=False,
1483                _exception=("FA2_OPERATORS_UNSUPPORTED", "FA2_PAUSED"),
1484            )