solana. Mint nft with updateAuthority not equal to owner - solana

it`s my first questions on stackoverflow :)
Id like to mint nft to my friend but еto reserve the right to update metadata.
I use my publickey like updateAuthority for CreateMetadataAccountV3InstructionAccounts
but response "Program log: Mint authority provided does not match the authority on the mint"
Thank you!!
const ownerPubkey = new web3.PublicKey(owner);
const payerPubkey = new web3.PublicKey(payer);
const updatePubkey = new web3.PublicKey(update);
const mint = web3.Keypair.generate();
const instructions: web3.TransactionInstruction[] = [];
const signers: web3.Keypair[] = [mint];
const userTokenAccoutAddress = getTokenWallet(ownerPubkey, mint.publicKey);
const metadataAccount = getMetadata(mint.publicKey);
const editionAccount = getMasterEdition(mint.publicKey);
instructions.push(
web3.SystemProgram.createAccount({
fromPubkey: ownerPubkey,
newAccountPubkey: mint.publicKey,
lamports: MINT_RENT,
space: MintLayout.span,
programId: TOKEN_PROGRAM_ID,
})
);
instructions.push(
createInitializeMintInstruction(
mint.publicKey,
0,
updatePubkey,
updatePubkey,
TOKEN_PROGRAM_ID
)
);
instructions.push(
createAssociatedTokenAccountInstruction(
payerPubkey,
userTokenAccoutAddress,
ownerPubkey,
mint.publicKey
)
);
const accounts: CreateMetadataAccountV3InstructionAccounts = {
metadata: metadataAccount,
mint: mint.publicKey,
mintAuthority: ownerPubkey,
payer: payerPubkey,
updateAuthority: updatePubkey,
};
const args: CreateMetadataAccountV3InstructionArgs = {
createMetadataAccountArgsV3: {
data,
isMutable: true,
collectionDetails: null,
},
};
instructions.push(createCreateMetadataAccountV3Instruction(accounts, args));
instructions.push(
createMintToInstruction(
mint.publicKey,
userTokenAccoutAddress,
ownerPubkey,
1
)
);
instructions.push(
createCreateMasterEditionV3Instruction(
{
edition: editionAccount,
...accounts,
},
{ createMasterEditionArgs: { maxSupply: 0 } }
)
);
I use my publickey like updateAuthority for CreateMetadataAccountV3InstructionAccounts
but response "Program log: Mint authority provided does not match the authority on the mint"

When you create the metadata account and mint tokens, you're specifying the mint authority as ownerPubkey, when you previously specified updatePubkey. You should change them to:
const accounts: CreateMetadataAccountV3InstructionAccounts = {
metadata: metadataAccount,
mint: mint.publicKey,
mintAuthority: updatePubkey,
payer: payerPubkey,
updateAuthority: updatePubkey,
};
and
instructions.push(
createMintToInstruction(
mint.publicKey,
userTokenAccoutAddress,
updatePubkey,
1
)
);

Related

Why is this contract call failing (rust-counter increment)?

I am attempting to call the increment in the counter contract here, which is deployed to my account on testnet, using the following script:
const nearAPI = require("near-api-js");
require("dotenv").config();
const {parseSeedPhrase} = require("near-seed-phrase");
async function call() {
const mneumonic = process.env.nearmneumonic0?.trim() || "";
const ACCOUNT_ID = process.env.nearacct0?.trim() || "";
const keyStores = nearAPI.keyStores;
const keyPair = nearAPI.KeyPair;
const connect = nearAPI.connect;
const keyStore = new keyStores.InMemoryKeyStore();
const PRIVATE_KEY = parseSeedPhrase(mneumonic);
const keyPair_ = keyPair.fromString(PRIVATE_KEY.secretKey);
await keyStore.setKey("testnet", ACCOUNT_ID, keyPair_);
const config = {
keyStore,
networkId: "testnet",
nodeUrl: "https://rpc.testnet.near.org",
};
const near = await connect(config);
const account = await near.account(ACCOUNT_ID);
const contract = new nearAPI.Contract(
account,
ACCOUNT_ID,
{
changeMethods: ["increment", "decrement", "reset"],
viewMethods: ["get_num"],
sender: account,
}
);
let response = await contract.increment(
{
args: {
//arg_name: "value"
},
gas: 300000000000000
}
);
console.log(response);
}
call();
However, the response thrown is al followed:
Failure [acct.testnet]: Error: Contract method is not found
...
ServerTransactionError: Contract method is not found
I have looked through some of the docs, which mention to add changeMethod/viewMethod, however it seems there is still errors thrown.
Any help much appreciated!

How do I "unwrap SOL" using the web3 sdk?

I need to unwrap some SOL using the web3 sdk. I'm wondering, Is it just a simple transfer from the wrapped account into SOL account or is it more complicated than that? Below Is just some sample code I've setup.
const emptyWSolAccount = async (amount:any) => {
const wsolAddress = await Token.getAssociatedTokenAddress(
ASSOCIATED_TOKEN_PROGRAM_ID,
TOKEN_PROGRAM_ID,
new PublicKey("So11111111111111111111111111111111111111112"),
wallet.publicKey
);
const wsolAccount = await connection.getAccountInfo(wsolAddress);
if (wsolAccount) {
const transaction = new Transaction({
feePayer: wallet.publicKey,
});
const instructions = [];
const lamports = amount * LAMPORTS_PER_SOL;
instructions.push(
SystemProgram.transfer({
fromPubkey: wsolAddress,
toPubkey: wallet.publicKey,
lamports: lamports, // 1 sol
})
);
transaction.add(...instructions);
transaction.recentBlockhash = await (
await connection.getRecentBlockhash()
).blockhash;
transaction.partialSign(wallet.payer);
const result = await connection.sendTransaction(transaction, [
wallet.payer,
]);
console.log({ result });
return { result };
}
return ;
};
This is not really explained anywhere, but unwrapping SOL actually means closing the wrapped SOL account.
So instead of using a SystemProgram.transfer instruction, you'll do:
instructions.push(
splToken.instructions.createCloseAccountInstruction(
wsolAddress,
wallet.publicKey,
wallet.publicKey,
)
);
This closes wsolAddress and sends the contents to wallet, assuming that wallet is the owner.
You can see the CLI implementation at https://github.com/solana-labs/solana-program-library/blob/3db53e278b543a040d3c970797b6be6f9ea5aef9/token/cli/src/main.rs#L1139-L1194

Retrying failed custom token transaction with '#solana/web3.js'

I want to send my deployed token other than sol using solana web3.js. My code works most of the time but sometimes the transaction fails.
I put a while loop so that when the transaction fails the client retries it with the sendRawTransaction function. The problem is that when it fails the first time it always fails after it.
const provider = await this.getProvider();
const publicKey = new web3.PublicKey(this.wallet);
const toPublicKey = new web3.PublicKey(
"the public key to send"
);
const mint = new web3.PublicKey(
"my token adress"
);
const connection = await new Connection(clusterApiUrl("mainnet-beta"));
const { signTransaction } = useWallet();
const fromTokenAccount = await this.getOrCreateAssociatedTokenAccount(
connection,
publicKey,
mint,
publicKey,
signTransaction
)
});
const toTokenAccount = await this.getOrCreateAssociatedTokenAccount(
connection,
publicKey,
mint,
toPublicKey,
signTransaction
);
const transferInstruction = await this.createTransferInstruction(
fromTokenAccount.address, // source
toTokenAccount.address, // dest
publicKey,
amount,
[],
TOKEN_PROGRAM_ID
);
const transaction = new Transaction().add(transferInstruction);
var blockHash = await connection.getLatestBlockhash('finalized');
transaction.feePayer = await publicKey;
console.log(blockHash.blockhash)
transaction.recentBlockhash = blockHash.blockhash;
// const provider = await this.getProvider();
const signed = await provider.signTransaction(transaction);
window.createEvent('openPopup', {
text: 'Your transaction is being validated by the Solana blockchain.',
loading: 30,
show: true
})
var nbRetry = 0;
while(true){
const signature = await connection.sendRawTransaction(signed.serialize())
this.post(`verifyTransaction`, {
signature,
})
.then(() => {
window.location.assign('/transaction_success')
})
.catch(async (error) => {
if (error.response.status === 403) {
if (nbRetry > 5){
window.createEvent('openPopup', {
show: true,
image: 'error.png',
text: 'The transaction failed.',
reload: true
})} else nbRetry++;
}}
})

Fungible asset max supply?

Does anyone know how I can add a max supply to a Metaplex fungible asset ?
const metadata = await Metadata.getPDA(mint.publicKey);
const createMetadataTx = new CreateMetadataV2(
{ feePayer: mint_authority.publicKey },
{
metadata,
metadataData: new DataV2({
uri :'https://xxxx-88-81-106-161.ngrok.io/sample-uri',
name: 'ttt',
symbol: 'ttt',
sellerFeeBasisPoints: 100,
creators: null,
collection: null,
uses: null,
tokenStandard: TokenStandard.Fungible
}),
updateAuthority: mint_authority.publicKey,
mint: mint.publicKey,
mintAuthority: mint_authority.publicKey,
},
);
const sig = await connection.sendTransaction(createMetadataTx, [mint_authority],{
skipPreflight: false,
} )
const txRpcResponse = await connection.confirmTransaction(sig)
According to the current Metadata Struct, there is no such field as max supply you can look more into the SPL token program it contains a field called supply to know more about it you can look here or checkout the Solana Program Library Repo

Update Metadata of Metaplex NFT

I have some problem in updating Metaplex NFT Metadata.
I used #metaplex/js and this is my code.
import { programs } from '#metaplex/js';
export const updateMetadataV1 = async () => {
let { metadata : {Metadata, UpdateMetadata, MetadataDataData, Creator} } = programs;
let signer = loadWalletKey(keyfile);
let nftMintAccount = new PublicKey("EC8gGdtVFDoTf3vEGbLvPp7SVWta2xQrs99iWMbaFrdE");
let metadataAccount = await Metadata.getPDA(nftMintAccount);
const metadat = await Metadata.load(solConnection, metadataAccount);
let newUri = "https://arweave.net/my arweave address";
if (metadat.data.data.creators != null) {
const creators = metadat.data.data.creators.map(
(el) =>
new Creator({
...el,
}),
);
let newMetadataData = new MetadataDataData({
name: metadat.data.data.name,
symbol: metadat.data.data.symbol,
uri: newUri,
creators: [...creators],
sellerFeeBasisPoints: metadat.data.data.sellerFeeBasisPoints,
})
const updateTx = new UpdateMetadata(
{ feePayer: signer.publicKey },
{
metadata: metadataAccount,
updateAuthority: signer.publicKey,
metadataData: newMetadataData,
newUpdateAuthority: signer.publicKey,
primarySaleHappened: metadat.data.primarySaleHappened,
},
);
let result = await sendAndConfirmTransaction(solConnection, updateTx, [signer]);
console.log("result =", result);
}
}
The transaction result has no error, it means transaction success.
I checked it on Solana Explorer.
But the metadata doesn't change. What's the matter?
To Solve this issue this code can be used, This is a low-level code that uses the mpl-token-metadata npm package to call the on-chain updateMetadata Function.
import { Wallet } from "#project-serum/anchor";
import * as anchor from "#project-serum/anchor";
import {createUpdateMetadataAccountV2Instruction,DataV2,UpdateMetadataAccountV2InstructionArgs,UpdateMetadataAccountV2InstructionAccounts} from "#metaplex-foundation/mpl-token-metadata"
const fs = require("fs");
(async() => {
// This is the Update Authority Secret Key
const secretKey = fs.readFileSync(
"/Users/pratiksaria/.config/solana/id.json",
"utf8"
);
const keypair = anchor.web3.Keypair.fromSecretKey(
Buffer.from(JSON.parse(secretKey))
);
const endpoint = "https://metaplex.devnet.rpcpool.com/";
const connection = new anchor.web3.Connection(endpoint);
const wallet = new Wallet(keypair);
console.log("Connected Wallet", wallet.publicKey.toString());
const TOKEN_METADATA_PROGRAM_ID = new anchor.web3.PublicKey(
"metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s"
);
// You have to enter your NFT Mint address Over Here
const mintKey = new anchor.web3.PublicKey("5iSxT33FyHWsnb8NYSytY17TTXfkFn62FiCyFVFxYhqY");
const [metadatakey] = await anchor.web3.PublicKey.findProgramAddress(
[
Buffer.from("metadata"),
TOKEN_METADATA_PROGRAM_ID.toBuffer(),
mintKey.toBuffer(),
],
TOKEN_METADATA_PROGRAM_ID
);
// BTW DeGods is my FAV collection although i cant afford one 🥲
const updated_data: DataV2 = {
name: "DeGods",
symbol: "DG",
uri: "https://metadata.degods.com/g/4924.json",
sellerFeeBasisPoints: 1000,
creators: [
{
address: new anchor.web3.PublicKey(
"CsEYyFxVtXxezfLTUWYwpj4ia5oCAsBKznJBWiNKLyxK"
),
verified: false,
share: 0,
},
{
address: wallet.publicKey,
verified: false,
share: 100,
},
],
collection: null,
uses: null,
};
const accounts:UpdateMetadataAccountV2InstructionAccounts = {
metadata: metadatakey,
updateAuthority: wallet.publicKey,
}
const args:UpdateMetadataAccountV2InstructionArgs = {
updateMetadataAccountArgsV2: {
data: updated_data,
updateAuthority: wallet.publicKey,
primarySaleHappened: true,
isMutable: true,
}
}
const updateMetadataAccount = createUpdateMetadataAccountV2Instruction(
accounts,
args
);
const transaction = new anchor.web3.Transaction()
transaction.add(updateMetadataAccount);
const {blockhash} = await connection.getLatestBlockhash();
transaction.recentBlockhash = blockhash;
transaction.feePayer = wallet.publicKey;
const signedTx = await wallet.signTransaction(transaction);
const txid = await connection.sendRawTransaction(signedTx.serialize());
console.log("Transaction ID --",txid);
})()
let blockhashObj = await solConnection.getLatestBlockhash();
updateTx.recentBlockhash = blockhashObj.blockhash;
updateTx.sign(alice);
let endocdeTransction = updateTx.serialize({
requireAllSignatures: false,
verifySignatures: false,
});
var signature = await solConnection.sendRawTransaction(endocdeTransction, {
skipPreflight: false,
});

Resources