zeppelin | Awesome conference website in 5 minutes | Theme library

The ERC-721 standard does not define a "best" or "correct" way to mint new tokens (such as whether it should be open or restricted) and it's up to each contract developer to implement or omit the minting feature in a way that reflects their needs.

Creating of NFTs ("minting") and destruction NFTs ("burning") is not included in the specification. Your contract may implement these by other means. Please see the event documentation for your responsibilities when creating or destroying NFTs.

But having a whitelist of addresses that are authorized to mint new tokens (e.g. MINTER_ROLE or onlyOwner) seems to be more common than allowing anyone to freely mint new tokens.

Even though it's theoretically possible to deploy new contract each time a new token is minted, it's not a standard approach (and I personally haven't seen any contract that does it). In most cases the minting process "just" creates a new ID, stores a new string/URL value associated with the ID, associates this new token with an owner address (of the token, not a contract owner), plus updates some metadata such as amount of tokens owned by an address (see example below).

The token owner can then transfer their tokens, give anyone control over their tokens, and do other stuff depending on the contract implementation.

The mappings that you point out in your question (_owners and _balances) suggest that they store token owner (not contract owner) addresses as well as amount of tokens held by each address.

Example:

1. Contract owner mints token ID 1 to address 0x123.

   • Value of _owners[1] is 0x123 (was 0, the default value)

   • Value of _balances[0x123] becomes 1 (was 0, the default value)

2. Contract owner mints token ID 2 to address 0x123.

   • Value of _owners[1] is still 0x123

   • Value of _owners[2] is now 0x123 (was 0, the default value)

   • Value of _balances[0x123] becomes 2 (because they now own 2 tokens)

Maybe something like this?

Since body.data.ethereum.address[0].balances is an array of objects body.data.ethereum.address[0].balances[0].currency.address is only going to access the very first of those objects.

You could use Array.map to get all addresses:

This will not work while using Impala with the existing Zeppelin %jdbc Interpreter as that interpreter strictly reads/interprets SQL statements and offers no ability to manipulate your result data using code.

The following two workarounds might help

Option 1: Instead of using %jdbc Interpreter to run the Impala query use %python or %spark (Scala) interpreters to run the Impala query via JDBC. Then do your data manipulation (cast to html link) in the same cell.

Example using Python Interpreter with jaydebeapi:

Spark works with the concept of partitions in order to parallelize the tasks among the workers. The dataframe is also partitioned and when the save action is called, each worker will save a portion of the dataframe creating multiple files.

In order to create a single file, just repartition or coalesce the dataframe into one partition:

You can try getting a tuple of object and string from the RDD, and use toIterable to convert to Iterable[(Object, String)]:

You can create a new service and leverage the interpreterSettingName label of the spark master pod. When zeppelin creates a master spark pod it adds this label and its value is spark. I am not sure if it will work for more than one pods in a per user per interpreter setting. Below is the code for service, do let me know how it behaves for per user per interpreter.

I could solve it with