A simple marketplace APT transfer

[memxor]

I don't have a full fledged marketplace. It is very basic, people can't list or borrow. They can just buy character (NFTs) from our predefined listings. I want something as basic as

On Buy -> APT from User's wallet to Pubisher wallet
On Sell -> APT from Publisher wallet to User's wallet

I've seen examlpes of vaults, but I think that is too much for such a simple usecase. The only issue is the publisher/admin can't sign, while sending tokens to ther user.

While this works coin::transfer<AptosCoin>(user, @publisher, race.price); but this doesn't coin::transfer<AptosCoin>(@publisher, user_pub_key, race.price);

If someone can help me with something very simple and easy to implement here, I will be really thankful!

[0xaptosj]

Unlike Solana, in Aptos pubkey and address are different things and we only work with address, you need to do coin::transfer<AptosCoin>(@publisher, user_address, race.price);

[MoonShiesty]

modules published under resource accounts (EOAs) can retrieve and then store their own signer_cap for use later:

// Stores permission config such as SignerCapability for controlling the resource account.
struct PermissionConfig has key {
    // Required to obtain the resource account signer.
    signer_cap: SignerCapability,
}

// Initialize PermissionConfig to establish control over the resource account.
// This function is invoked only when this package is deployed the first time.
fun init_module(account: &signer) {
    let signer_cap = resource_account::retrieve_resource_account_cap(account, @protocol_deployer);
    move_to(account, PermissionConfig {
        signer_cap,
    });
}
    
// Can be called to obtain the resource account signer.
fun get_signer(): signer acquires PermissionConfig {
    let signer_cap = &borrow_global<PermissionConfig>(@mirage_core).signer_cap;
    account::create_signer_with_capability(signer_cap)
}

then inside of the module that creates/mints the token (and checks signer is admin), you can transfer the ownership of the token(nft) to the user:

// mint nft(token) to mint_to_addr
public fun mint_nft(admin: &signer, mint_to_addr: address) {
  // check admin
  ...
  
  // mint token
  let constructor_ref = token::create_numbered_token(
        &get_signer(), // creator
        string::utf8(b"collection_name), // collection_name
        string::utf8(b"token_description"), // description
        string::utf8(b"token_name"), // prefix
        string::utf8(b""), //no suffix
        option::none(), // royalty
        string::utf8(b"www.example.com"),
  );
  // convert constructor_ref into object
  let nft_object = object::object_from_constructor_ref<Token>(&constructor_ref);
  
  // transfer token from module(creator) to new owner.
  object::transfer(&get_signer(), nft_object, mint_to_addr)
}

for a more complicated example about how to manage the module's signer_cap see: package_manager