AR-Examples | Augmented Reality examples for the web | Augmented Reality library

There are several issues in the existing repository for /mint_nft.

The REST-API implemented doesn't follow the correct format when minting an NFT. I have created a PR to address the issue

In short, the function call to mint an NFT is missing one argument, receiver_id, and the format and name of metadata is not correct. It should be token_metadata: {} // type is object, not string.

If we change the postData to

It’s certainly possible to have a PersistentVector, and inside each activity have a PersistentVector with friends. However, using this datastructure, I think you end up with a shared list of friends for all activites (unless you use a unique prefix). If you use PersistentVector for your activities, then it’s possible to use a regular list (string[]) for your friends to isolate it inside one activity. Otherwise, you would need to store the PersistentVector of friends using the id of your activity (maybe as the unique prefix like below)

As mentioned here, there is no way to withdraw/transfer tokens from some other account, so you should design your contract in such a way that it requires the user to deposit some tokens into your contract (attach tokens with a deposit-like function call). There are nice examples of this pattern in the core contracts:

• lockup contract locks funds according to the schedule
• staking-pool locks the tokens for delegated stake
• multisig contract uses two calls to enable 2FA by using add_request function with all the parameters of a future call and confirm function that takes the previous request and executes it

Please try sudo npm install -g asbuild.

Feel free to +1 on https://github.com/near-examples/guest-book/issues/543

If I understand the question correctly you'd like to combine nft_mint with some sort of payable action that will pay the original creator of some "NFT token type"?

You can check the NFT Market repo here: https://github.com/near-apps/nft-market

This repository uses a separate market account and contract to allow NFT Owners to put NFTs up for sale. A little more than what you are looking for I think.

There is also a variant that uses "lazy minting" to only mint the NFTs when a user buys them from the market contract: https://github.com/near-apps/gnr8/

Again, it's a little more than what I think you want because the payment and buying is happening in a separate contract and the NFT transfer and minting is happening in the NFT contract, which is called from the market contract.

If you're looking for something to add your own payable NFT method to, you could start with this: https://github.com/near-apps/nft-series/

Which allows you to define an NFT type and you could charge users to mint 1/N of that type by making the nft_mint_type method payable and NOT require the owner of the type to be the minter.

FYI these approaches are non-standard, but work.

Feel free to reach out directly on Discord if you need any help with the examples above.

Counter is not a valid account-id. Uppercase letters in accounts-id are not allowed). You need to pass the proper account-id.

I would expected your account-id to be something of the form takahashi.testnet or dev-1623565709996-68004511819798 (if contract was deployed using near dev-deploy command).

This is how you can deploy to testnet using dev-deploy, and call view function using near-cli:

The UnorderedMap type uses a trie. An attacker could unbalance the trie by repeatedly pushing keys onto the trie that push the depth of one side of the trie deep. This would reduce performance of trie lookups on names beneath the attacker's.

A mitigation to the attock is to store hashes of the keys. The hashes would be equally distributed among possible values. The attacker could still perform the attack, but generating specific hashes is hard, so some protocols say.

Another mitigation to the attack is to use a LookupMap, which uses an AVL tree, which automatically rebalances its tree.

The attack isn't significantly threatening. The worst the attacker can do is punish a small range of key values, by repeatedly paying the storage costs to push an extremely limited range of key values farther down the trie. It therefore, probably isn't worth paying the cost to hash the keys.

However, for trees that store a large number of keys, hashing keys, or a LookupMap, may still be worth considering, as an unbalanced trie is very likely to result.

To recap, we reviewed the comparison of cost between:

• Hashing each key before storing and retreiving to an UnorderedMap
• Allowing the "attack" described above
• Using a LookupMap instead of an UnorderedMap

thanks @MikePurvis for explanation.

Take a look at the lockup contract example instead. It uses the following:

Usually, this error appears when the is a problem with the website SSL certificate or if you don't allow the website to access your phone's camera. In your case, it seems like you just need to give permissions to the website. You should also make sure your chrome version is up to date.