The code also defines the type for the value that entrypoints return: a list of operations and the new value of the storage.
-
Add code to implement the required transfer, balance_of, and update_operators entrypoints:
@entry
const transfer = (p: FA2Impl.TZIP12.transfer, s: storage): ret => {
const ret2: [list<operation>, FA2Impl.NFT.storage] =
FA2Impl.NFT.transfer(
p,
{
ledger: s.ledger,
metadata: s.metadata,
token_metadata: s.token_metadata,
operators: s.operators,
}
);
return [
ret2[0],
{
...s,
ledger: ret2[1].ledger,
metadata: ret2[1].metadata,
token_metadata: ret2[1].token_metadata,
operators: ret2[1].operators,
}
]
};
@entry
const balance_of = (p: FA2Impl.TZIP12.balance_of, s: storage): ret => {
const ret2: [list<operation>, FA2Impl.NFT.storage] =
FA2Impl.NFT.balance_of(
p,
{
ledger: s.ledger,
metadata: s.metadata,
token_metadata: s.token_metadata,
operators: s.operators,
}
);
return [
ret2[0],
{
...s,
ledger: ret2[1].ledger,
metadata: ret2[1].metadata,
token_metadata: ret2[1].token_metadata,
operators: ret2[1].operators,
}
]
};
@entry
const update_operators = (p: FA2Impl.TZIP12.update_operators, s: storage): ret => {
const ret2: [list<operation>, FA2Impl.NFT.storage] =
FA2Impl.NFT.update_operators(
p,
{
ledger: s.ledger,
metadata: s.metadata,
token_metadata: s.token_metadata,
operators: s.operators,
}
);
return [
ret2[0],
{
...s,
ledger: ret2[1].ledger,
metadata: ret2[1].metadata,
token_metadata: ret2[1].token_metadata,
operators: ret2[1].operators,
}
]
};
You will add other entrypoints later, but these are the three entrypoints that every FA2 contract must have.
Because these required entrypoints must have specific parameters, the code re-uses types from the FA2Impl object for those parameters.
For example, the FA2Impl.TZIP12.transfer type represents the parameters for transferring tokens, including a source account and a list of target accounts, token types, and amounts.
-
The transfer entrypoint accepts information about the tokens to transfer.
This implementation uses the FA2Impl.NFT.transfer function from the template to avoid having to re-implement what happens when tokens are transferred.
-
The balance_of entrypoint sends information about an owner's token balance to another contract.
This implementation re-uses the FA2Impl.NFT.balance_of function.
-
The update_operators entrypoint updates the operators for a specified account.
This implementation re-uses the FA2Impl.NFT.update_operators function.
-
After those entrypoints, add code for the mint entrypoint:
@entry
const mint = (
[token_id, name, description, symbol, ipfsUrl]: [
nat,
bytes,
bytes,
bytes,
bytes
],
s: storage
): ret => {
if (! Set.mem(Tezos.get_sender(), s.administrators)) return failwith("1");
const token_info: map<string, bytes> =
Map.literal(
list(
[
["name", name],
["description", description],
["interfaces", (bytes `["TZIP-12"]`)],
["artifactUri", ipfsUrl],
["displayUri", ipfsUrl],
["thumbnailUri", ipfsUrl],
["symbol", symbol],
["decimals", (bytes `0`)]
]
)
) as map<string, bytes>;
return [
list([]) as list<operation>,
{
...s,
ledger: Big_map.add(token_id, Tezos.get_sender(), s.ledger) as
FA2Impl.NFT.ledger,
token_metadata: Big_map.add(
token_id,
{ token_id: token_id, token_info: token_info },
s.token_metadata
),
operators: Big_map.empty as FA2Impl.NFT.operators,
}
]
};
The FA2 standard does not require a mint entrypoint, but you can add one if you want to allow the contract to create more tokens after it is originated.
If you don't include a mint entrypoint or a way to create tokens, you must initialize the storage with all of the token information when you originate the contract.
This mint entrypoint accepts a name, description, symbol, and IPFS URL to an image.
It also accepts an ID number for the token, which the front end will manage; you could also set up the contract to remember the ID number for the next token.
First, this code verifies that the transaction sender is one of the administrators.
Then it creates a token metadata object with information from the parameters and adds it to the token_metadata big-map in the storage.
Note that the decimals metadata field is set to 0 because the token is an NFT and therefore has only one unit.
Note that there is no built-in way to get the number of tokens in the contract code; the big-map does not have a function such as keys() or length().
If you want to keep track of the number of tokens, you must add an additional element in the storage and increment it when tokens are created or destroyed.
You can also get the number of tokens by analyzing the contract's storage from an off-chain application.
-
Run one of these commands to accept or decline LIGO's analytics policy:
ligo analytics accept to send analytics data to LIGOligo analytics deny to not send analytics data to LIGO
-
Save the contract and compile it by running this command:
TAQ_LIGO_IMAGE=ligolang/ligo:1.3.0 taq compile nft.jsligo
Taqueria compiles the contract to the file artifacts/nft.tz.
It also creates the file nft.storageList.jsligo, which contains the starting value of the contract storage.
-
Open the file contracts/nft.storageList.jsligo and replace it with this code :
#import "nft.jsligo" "Contract"
const default_storage : Contract.storage = {
administrators: Set.literal(
list(["tz1VSUr8wwNhLAzempoch5d6hLRiTh8Cjcjb" as address])
) as set<address>,
ledger: Big_map.empty as Contract.FA2Impl.NFT.ledger,
metadata: Big_map.literal(
list(
[
["", bytes `tezos-storage:data`],
[
"data",
bytes
`{
"name":"FA2 NFT Marketplace",
"description":"Example of FA2 implementation",
"version":"0.0.1",
"license":{"name":"MIT"},
"authors":["Marigold<contact@marigold.dev>"],
"homepage":"https://marigold.dev",
"source":{
"tools":["Ligo"],
"location":"https://github.com/ligolang/contract-catalogue/tree/main/lib/fa2"},
"interfaces":["TZIP-012"],
"errors": [],
"views": []
}`
]
]
)
) as Contract.FA2Impl.TZIP16.metadata,
token_metadata: Big_map.empty as Contract.FA2Impl.TZIP12.tokenMetadata,
operators: Big_map.empty as Contract.FA2Impl.NFT.operators,
};
This code sets the initial value of the storage.
In this case, the storage includes metadata about the contract and empty big-maps for the ledger, token metadata, and operators.
It sets the test account Alice as the administrator, which is the only account that can mint tokens.
-
Optional: Add your address as an administrator or replace Alice's address with your own.
Note that only the addresses in the administrators list will be able to create tokens.
-
Compile the contract:
TAQ_LIGO_IMAGE=ligolang/ligo:1.3.0 taq compile nft.jsligo
-
Use one of these options to set up a Ghostnet account to use to deploy (originate) the contract:
-
To use your own account, open the .taq/config.local.testing.json file and add your public key, address, and private key, so the file looks like this:
{
"networkName": "ghostnet",
"accounts": {
"taqOperatorAccount": {
"publicKey": "edpkvGfYw3LyB1UcCahKQk4rF2tvbMUk8GFiTuMjL75uGXrpvKXhjn",
"publicKeyHash": "tz1VSUr8wwNhLAzempoch5d6hLRiTh8Cjcjb",
"privateKey": "edsk3QoqBuvdamxouPhin7swCvkQNgq4jP5KZPbwWNnwdZpSpJiEbq"
}
}
}
Then make sure that the account has tez on Ghostnet.
Use the faucet at https://faucet.ghostnet.teztnets.xyz to get tez if you need it.
-
To let Taqueria generate an account for you, follow these steps:
-
Run the command taq deploy nft.tz -e "testing", which will fail because you do not have an account configured in Taqueria.
The response includes the address of an account that Taqueria generated for you and added to the .taq/config.local.testing.json file automatically.
-
Fund the account from the faucet at https://faucet.ghostnet.teztnets.xyz.
-
Compile and deploy the contract to Ghostnet by running this command:
taq deploy nft.tz -e "testing"
Taqueria deploys the contract to Ghostnet and prints the address of the contract, as in this image:
Now the backend application is ready and you can start on the frontend application.
