k-rs | An attempt to create K language interpreter with rust | Interpreter library

You need to make sure you are updating the RaffleDetails instance that is in the map, not a copy/clone of it.

I'm not familiar with UnorderedMap, but it seems to me the get() method returns a copy of the value that is in the map, so you are only updating the copied value. I don't know if UnorderedMap allows you to mutate a value in it directly (skimming through the docs, I don't see such a method). What you can do though is re-insert the modified RaffleDetails into the raffles map (so as to replace the old one with the modified one).

I'm talking about something like this (I haven't tested compiling it):

If you look into the examples, normally in such a case gtk::GestureClick is used. To detect right clicks, you can use it like so:

Currently the answer is to copy the mint function from the standard implementation and customize as you see fit.

The better interface will be coming in the future updates.

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.

For pub fn widg(&self) -> T { to work, it would be necessary to make a full clone of the T value. W ith all the bounds in your question, that would look like this:

Here is some implementation of burn:

ValidAccountId is a wrapper around a AccountId, which validates the string to ensure that it is a valid format. This is usually done when deserializing the JSON sent when calling the contract method. However, here you have to be explicit:

Currently there is no API to burn NEAR tokens directly. One workaround is to set the beneficiary account id to system. system is an account that can never be created and is used internally for refunds. When the beneficiary account does not exist, the tokens transferred through account deletion are automatically burnt.

For some reason it appears that the relative path notation was causing the issue: