Lambda Function parameter infer type - External Struct

[Alexzander-Stone]

Discord user ID

spielcrypto.apt

Describe your question in detail.

My Token Struct parameter can't have it's id field accessed.
vector::for_each's lambda parameter's type can not be inferred.

What error, if any, are you getting?

error[E04010]: cannot infer type
   ┌─ /home/spielcrypto/ghost-lost/ghost-lost/ghostly-contract/sources/ghostly.move:17:69
   │
16 │         vector::for_each<Token>(nfts, |nft| {
   │                                        --- Could not infer the type before field access. Try annotating here
17 │             vector::push_back<TokenId>(&mut trackUserAssets.tokens, nft.id);
   │                                                                     ^^^^^^ Unbound field 'id'

{
  "Error": "Move compilation failed: Compilation error"
}

What have you tried or looked at? Or how can we reproduce the error?

No response

Which operating system are you using?

N/A

Which SDK or tool are you using? (if any)

Aptos CLI

Describe your environment or tooling in detail

No response

[Alexzander-Stone]

Inferring type from a lambda expression's Struct parameter

Hey spielcrypto.apt, when accessing a Struct's fields not owned by your module, you'll need to use available accessors on the Struct's originating module.
For Token, you can make use of get_token_id.

Applied to your use-case

vector::for_each<Token>(nfts, |nft| {
    let id = token::get_token_id(&nft);
    vector::push_back<TokenId>(&mut trackUserAssets.tokens, id);
    // ......
}

[spielcrypto]

Yes that works thanks a lot!
The only thing is that the error Could not infer the type before field access. Try annotating here is misleading

[spielcrypto]

but now if I have this:

vector::for_each<NFT>(nfts, |nft| {
            let token_addr = object::object_address(&nft.token);
            let token = borrow_global<Token>(token_addr);
            let id = get_token_id(token);

            vector::push_back<TokenId>(&mut trackUserAssets.tokens, id);
            deposit_token(account, nft);
        });

I get this error:

error[E04007]: incompatible types
    ┌─ /home/spielcrypto/ghost-lost/ghost-lost/ghostly-contract/sources/ghostly.move:25:9
    │  
 25 │ ╭         vector::for_each<NFT>(nfts, |nft| {
    │                            --- Given: '(ghostly=0x1)::keep::NFT'
 26 │ │             let token_addr = object::object_address(&nft.token);
 27 │ │             let token = borrow_global<Token>(token_addr);
 28 │ │             let id = get_token_id(token);
    · │
 31 │ │             deposit_token(account, nft);
 32 │ │         });
    │ ╰──────────^ Invalid call of '(std=0x1)::vector::for_each'. Invalid argument for parameter 'f'
    │  
    ┌─ /home/spielcrypto/.move/https___github_com_aptos-labs_aptos-core_git_testnet/aptos-move/framework/aptos-token/sources/token.move:955:55
    │
955 │     public fun deposit_token(account: &signer, token: Token) acquires TokenStore {
    │                                                       ----- Expected: '(aptos_token=0x3)::token::Token'

error[E04010]: cannot infer type
   ┌─ /home/spielcrypto/ghost-lost/ghost-lost/ghostly-contract/sources/ghostly.move:26:30
   │
26 │             let token_addr = object::object_address(&nft.token);
   │                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Cannot infer the type parameter `T` for generic function `(aptos_framework=0x1)::object::object_address`. Try providing a type parameter.

error[E04010]: cannot infer type
   ┌─ /home/spielcrypto/ghost-lost/ghost-lost/ghostly-contract/sources/ghostly.move:26:54
   │
25 │         vector::for_each<NFT>(nfts, |nft| {
   │                                      --- Could not infer the type before field access. Try annotating here
26 │             let token_addr = object::object_address(&nft.token);
   │                                                      ^^^^^^^^^ Unbound field 'token'

error[E05001]: ability constraint not satisfied
    ┌─ /home/spielcrypto/ghost-lost/ghost-lost/ghostly-contract/sources/ghostly.move:27:25
    │
 27 │             let token = borrow_global<Token>(token_addr);
    │                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    │                         │             │
    │                         │             The type '(aptos_token=0x3)::token::Token' does not have the ability 'key'
    │                         Invalid call of 'borrow_global'
    │
    ┌─ /home/spielcrypto/.move/https___github_com_aptos-labs_aptos-core_git_testnet/aptos-move/framework/aptos-token/sources/token.move:158:12
    │
158 │     struct Token has store {
    │            ----- To satisfy the constraint, the 'key' ability would need to be added here

error[E04001]: restricted visibility
   ┌─ /home/spielcrypto/ghost-lost/ghost-lost/ghostly-contract/sources/ghostly.move:27:25
   │
27 │             let token = borrow_global<Token>(token_addr);
   │                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   │                         │             │
   │                         │             The type '(aptos_token=0x3)::token::Token' was not declared in the current module. Global storage access is internal to the module'
   │                         Invalid call to borrow_global.

The NFT struct is this:

    struct NFT has key, copy, drop {
        token: Object<Token>,
        collection: Object<Collection>,
    }

It is like inside for_each I cannot get any prop from any Struct

[spielcrypto]

In then end following your suggestion of using Digital Asset Aptos standard I did this:

public fun send_to_ghostly_world(account: &signer, nfts: vector<Object<Token>>) acquires TrackUserAssets {
        let account_addr = signer::address_of(account);
        let trackUserAssets = borrow_global_mut<TrackUserAssets>(account_addr);

        vector::for_each<Object<Token>>(nfts, |nft| {
            let token_addr = object::object_address(&nft);

            vector::push_back<address>(&mut trackUserAssets.tokens, token_addr);
            object::transfer(account, nft, @ghostly);
        });
    }

but now I want to implement the claim feature where contract send back the digital asset. If the method is this one
object::transfer(signer, nft, to); how do I represent the contract as a signer?

[spielcrypto]

and now I change to this:

public fun send_to_ghostly_world(account: &signer, nfts: vector<Object<Token>>) {
        let account_addr = signer::address_of(account);

        let constructor_ref = object::create_object(account_addr);


        let token_signer = object::generate_signer(&constructor_ref);
        
        vector::for_each<Object<Token>>(nfts, |nft| {
            let track_user_asset = TrackUserAsset{
                token: option::some(nft)
            };

            move_to(account, track_user_asset);

            let track_user_asset_obj = object::address_to_object<TrackUserAsset>(signer::address_of(&token_signer));

            object::transfer_to_object(account, nft, track_user_asset_obj);
        });
    }

In this case can I recover all the objects created by the signer?

[Alexzander-Stone]

Hi @dancespiele, it might help if you describe what you're attempting to solve with each method in your module. Right now for me, it's a bit confusing why you're repeatedly calling move_to within your vector::for_each call.

Digital Asset examples

There's a good deal of examples within the primary aptos-core repo. Here's a few:

• Token object examples
• Marketplace

Along with the Aptos Learn examples I linked, prior:

• Aptogotchi Intermediate: Token Standards - Digital Assets
• NFT Marketplace

[spielcrypto]

Yes sure, I want something simple, a contract which have 2 entry functions, one where user can send NFTs to the contract and other to recover the NFTs that the user sent

[Alexzander-Stone]

If that's the case @dancespiele, then I think using the NFT Marketplace as your base template and making modifications to it is your best bet!

At the very least, understanding how Listings work (and what needs to be modified for just holding the NFT) and the entry functions will get you to 90% of the way there.