What is Aux account?
I've created my own spl-token. I can mint the initial supply for my own account with my main address. I created another address and create the token account for it:
spl-token create-account thisismytokenid solana-wallets/new.json
And then I minted my spl-token to the new address like so:
spl-token mint thisismytokenid 1000 solana-wallets/new.json
The token ended up in my main account. When I run the spl-token accounts command, it lists two different accounts, with the latest being an Aux account. What is that? So I can't create a token account nor mint token for another address?
Aux accounts are non-associated token accounts, or non-canonical.
You can use multiple accounts, but there is only one associated token account per mint. It is recommended to only use the associated token account.
Related
I have create a token on the devote and have created token account which I can transfer my token to successfully. I notice that a Solana fee is taken when I do this.
I also understand that I have to deposit enough Solana into an account to pay for rent or have 2 years worth of Solana to make it exempt.
When I create the account (using the code below) is it automatically making the accounts rent exempt or do I have to transfer additional Solana to do so.
How can I do this?
Code:
const tokenAccount = await getOrCreateAssociatedTokenAccount(
connection,
payer,
mint,
payer.publicKey
)
All new accounts now require to be rent exempt cf https://docs.solana.com/developing/programming-model/accounts#rent
So any accounts initialised successfully will be rent exempt. You don't have to worry about anything
Yes, an associated token account created by this call will be rent exempt. You can see it in the associated-token-program source code.
This is my situation:
I have created a wallet
solana-keygen new
I have created my own custom SPL Token
spl-token create-token
Then I created an Account for this SPL Token
spl-token create-account
The SPL token is now in my wallet A
In the Solana Program, I would like to programmatically transfer the custom SPL token from Wallet A to Alice(user) wallet when certain conditions are met (for example, when Alice answered a quiz correctly, she will be awarded some custom SPL token).
How do I authorise the Solana Program to deduct from Wallet A (which I had created) and transfer the tokens to Alice wallet?
Please advise me how to go about doing this. Really appreciate this.
To transfer an SPL token within a program, your best option is to have wallet A owned by a program-derived address, and then your program can transfer the tokens from wallet A based on any logic it wants.
So first, transfer the ownership to your program-derived address:
spl-token authorize <WALLET_2_ADDRESS> owner <PROGRAM_DERIVED_ADDRESS>
Then in your program, you can transfer to Alice with something like:
let transfer_instruction = spl_token::instruction::transfer(
&token_program.key,
&wallet_a_token_account.key,
&alice_token_account.key,
&program_derived_account.key,
&[],
transfer_amount,
)?;
let required_accounts_for_transfer = [
wallet_a_token_account.clone(),
alice_token_account.clone(),
program_derived_account.clone(),
];
invoke_signed(
&transfer_instruction,
&required_accounts_for_transfer,
&[
&[b"your", b"seeds", b"here",]
]
)?;
This was adapted from a full example for transferring SPL tokens within a program: https://solanacookbook.com/references/programs.html#how-to-do-cross-program-invocation
More information about program-derived addresses at https://solanacookbook.com/references/programs.html#how-to-create-a-pda, with an example of how to create an account.
I created a Solana token with a test wallet/account. Now I want to transfer authority to another account and delete the test one. Is there any way to do that?
You can do that through spl-token authorize on the CLI, or the SetAuthority instruction https://github.com/solana-labs/solana-program-library/blob/2d770628ef0fc05c22b36404cfd9aebd3b59c110/token/program/src/instruction.rs#L977
Note that it is an antipattern to transfer the ownership of an Associated Token Account: https://spl.solana.com/associated-token-account
In that case, the best practice is to create an associated token account for the recipient's wallet, transfer the tokens, and then close the first account.
I am currently thinking about creating a dapp that connects to a phantom wallet on solana. A user account will be created upon connection Signup/Login a User. I'm not sure how to verify the public address. Wallets will pass information to the frontend and i would have to forward this information to the backend, thus it is manipulable and useless... How do I prevent people from sending fake addresses to the server and signing up to any account they want? I thought about signing a message but why is this not done on e.g. opensea.io(Eth/Metamask)?
How do I prevent people from sending fake addresses to the server and signing up to any account they want?
Make them sign a message.
I thought about signing a message but why is this not done on e.g. opensea.io(Eth/Metamask)?
This is not done on OpenSea because OpenSea does not create or manage user accounts for its users. The app relies entirely on the PKI of the user's Web3 provider (such as MetaMask).
Ask yourself why you need to create a user account for your users on your backend. If you need to create such an account, then make the user sign a message. If you don't need to create a user account, then just let the user authenticate directly with the blockchain using their own PKI like OpenSea does.
Why not create the Keypair (public + private key) in the backend itself? Since you're creating a new account on signup. Send a request to the backend and create account and return the public key to the user.
But instead of doing this. You can ask the user to create a new wallet and singup using something like a phantom wallet. Did that help?
I want to make a transfer from my wallet to another wallet with code. I use web3.js and I made a Solana transfer, but I don't know how to make an NFT transfer.
NFTs on Solana are represented as SPL tokens, which can be transferred in JS using the "#solana/spl-token" package on npm: https://www.npmjs.com/package/#solana/spl-token
There's an example of how to use it at https://github.com/solana-labs/solana-program-library/blob/master/token/js/examples/createMintAndTransferTokens.ts and in the repo tests.
You can find more information on SPL tokens at https://spl.solana.com/token
NFT transfer is same as normal spl-token transfer.
Prior to transfer NFT, you need to know its Token Mint Address or its Associated Token Account of yours.
Also need to know receiver's Associated Token Account of NFT Mint Token Account.
If receiver doesn't have associated token account, you or he need to create it first.
If you are not familiar with the account types, please read my article on medium.
https://medium.com/#blockchainlover2019/how-to-verify-ownership-of-metaplex-nft-programmatically-at-on-chain-1059418c3c6
Transferring token by using web3 is easy and not knowhow knowledge.
This is my code from Solana program (smart contract), which transfers nft from one to another.
let transfer_ix = spl_token::instruction::transfer(
token_program.key,
nft_account_to_send.key,
nft_account_to_receive.key,
&pda,
&[],
1
)?;
invoke_signed(
&transfer_ix,
&[
nft_account_to_send.clone(),
nft_account_to_receive.clone(),
pda_account.clone(),
token_program.clone(),
],
&[&[&b"nft_transfer_is_easy"[..], &[_nonce]]]
)?;
I will add another code for you, which runs on web3.