Invalid type passed!
Received:
{type}
Expected one of:
{asideVariants.join(", ")}
: <>
{title &&
{title}
}
{children}
}
;
};
In order to mint new jettons, that particular Jetton must be mintable. Otherwise, it's impossible.
Next, only mintable Jettons are considered.
Minting is not a specified operation in any of the existing TEPs.
Its implementation is left to the developer's choice.
The following `typescript` code example is based on the minting implementation in
[Notcoin jetton minter contract](https://github.com/OpenBuilders/notcoin-contract/blob/main/contracts/jetton-minter.fc).
This example contains a manual assembly of all the necessary messages and is useful for studying their possible structure.
```typescript theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
import { Address, beginCell, internal, toNano } from "@ton/core";
import { TonClient, WalletContractV4 } from "@ton/ton";
import { mnemonicToPrivateKey } from "@ton/crypto";
async function main() {
const jettonMasterAddress = Address.parse('');
const receiverAddress = Address.parse('');
const destinationAddress = Address.parse('');
// let's add some forward_payload
const forwardPayload = beginCell()
.storeUint(0, 32) // 0 opcode means we have a comment
.storeStringTail('Mint')
.endCell();
// Forming the master message
// internal transfer is also unspecified by the standard, but there is a suggested format in TEP 0074
const masterMessage = beginCell()
.storeUint(0x178d4519, 32) // opcode for jetton transfer-internal
.storeUint(0, 64) // query id
.storeCoins(toNano(5)) // jetton amount, amount * 10^9. That is an amount we want to mint
.storeAddress(jettonMasterAddress) // from_address. For minting could be any. The Jetton wallet will check from context that the sender is the Jetton master contract and accept the transfer.
.storeAddress(destinationAddress) // response destination
.storeCoins(toNano('0.02')) // forward_ton_amount - if >0, will send notification message
.storeBit(1) // either forward_payload
.storeRef(forwardPayload) // we have forward_payload, store it as a reference
.endCell();
// forming the mint message
const mintMessageBody = beginCell()
.storeUint(0x642b7d07, 32) // opcode for mint
.storeUint(0, 64) // query id
.storeAddress(receiverAddress) // the user's regular wallet address
.storeCoins(toNano(0.1)) // Toncoin intended to user's Jetton wallet
.storeRef(masterMessage) // internal transfer message
.endCell();
const mintMessage = internal({
to: jettonMasterAddress,
value: toNano('0.1'),
bounce: true,
body: mintMessageBody
});
// connect to your regular wallet
const client = new TonClient({
endpoint: 'https://toncenter.com/api/v2/jsonRPC',
});
const provider = client.provider(destinationAddress);
const MNEMONIC = process.env.MNEMONIC;
if (!MNEMONIC) throw new Error("Set MNEMONIC to a test mnemonic (testnet).");
const keyPair = await mnemonicToPrivateKey(MNEMONIC.split(" "));
const walletContract = WalletContractV4.create({
workchain: 0,
publicKey: keyPair.publicKey,
});
// send the mint message through your wallet
const seqno = await walletContract.getSeqno(provider);
await walletContract.sendTransfer(provider, {
seqno: seqno,
secretKey: keyPair.secretKey,
messages: [
mintMessage,
],
});
}
void main();
```
However, there is an [SDK](https://github.com/ton-community/assets-sdk) that allows you to avoid manually creating all the necessary messages.
An example of how it can be used to send the mint message is provided below:
```typescript theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
import { Address } from '@ton/core';
import { AssetsSDK, PinataStorageParams, createApi, createSender, importKey } from "@ton-community/assets-sdk";
async function main() {
const NETWORK = 'testnet';
const api = await createApi(NETWORK);
const keyPair = await importKey(process.env.MNEMONIC!);
const sender = await createSender('highload-v2', keyPair, api);
const storage: PinataStorageParams = {
pinataApiKey: process.env.PINATA_API_KEY!,
pinataSecretKey: process.env.PINATA_SECRET!,
};
const sdk = AssetsSDK.create({
api: api,
storage: storage,
sender: sender,
});
const JETTON_ADDRESS = Address.parse('MY_JETTON_ADDRESS');
const jetton = sdk.openJetton(JETTON_ADDRESS);
const RECEIVER_ADDRESS = Address.parse('RECEIVER_ADDRESS');
await jetton.sendMint(sender, RECEIVER_ADDRESS, 1200000n);
}
void main();
```
Finally, you can use web services as [TON MINTER](https://minter.ton.org/) and avoid writing code, just follow the guides.