PLX

Guide · TON/GRAM Jetton

How to Create Your Own Crypto Token (Jetton) on TON/GRAM Without Code

Step-by-step guide to launching an audited fungible token on the TON/GRAM Blockchain using Phalanx Toolkit — no Solidity, no custom Tolk, no manual contract upload.

A live walk-through of every step, in order. Click and hold the demo to pause; release to resume.

Step 1: Sign upStep 2: Pick or describeStep 3: CustomizeStep 4: PayStep 5: Deploy
Tonviewer · Source code
● verified
 1// SPDX-License-Identifier: MIT
 2// PhalanxToolkit · JettonMinter · audited
 3import "@stdlib/tvm-dicts"
 4 
 5const op::transfer = 0xf8a7ea5;
 6const op::burn     = 0x595f07bc;
 7const op::mint     = 0x178d4519;
 8 
 9global storage::admin: address;
10global storage::total_supply: int;
11global storage::content: cell;
12global storage::wallet_code: cell;
13 
14fun loadStorage() {
15    var ds = getData().beginParse();
16    storage::total_supply = ds.loadCoins();
17    storage::admin        = ds.loadAddress();
18    storage::content      = ds.loadRef();
19    storage::wallet_code  = ds.loadRef();
20}
21 
22fun saveStorage() {
23    setData(beginCell()
24        .storeCoins(storage::total_supply)
25        .storeSlice(storage::admin)
26        .storeRef(storage::content)
27        .storeRef(storage::wallet_code)
28        .endCell());
29}
30 
31fun onInternalMessage(msg: cell) {
32    val cs = msg.beginParse();
33    val flags = cs.loadUint(4);
34    if (flags & 1) { return; }     // bounced
35 
36    val sender = cs.loadAddress();
37    cs.skipBits(64 + 32);          // value, fwd_fee
38    val body = cs.loadRef();
39    val op = body.beginParse().loadUint(32);
40 
41    loadStorage();
42    if (op == op::mint) { handleMint(sender, body); }
43    elseif (op == op::burn) { handleBurn(sender, body); }
44    saveStorage();
45}
46 
47// audited 2026-04-30 · 60/60 tests passed
48// keys: operator-only mint, holder-only burn, no admin escape

Match against on-chain bytecode

EQDx7…y9fQ · 142 lines · 60/60 tests passed

Open in Tonviewer →
01

Step 1 of 6

Sign up

Click "Build my token" and authenticate with Google or GitHub. Takes about 10 seconds — no credit card needed yet.

Six steps to your own Jetton

  1. Sign in to Phalanx Toolkit

    Open https://plx.foundation and sign in with Google or GitHub. This creates your deploy dashboard and audit packet inbox — your Tonkeeper wallet is connected later via TON Connect.

    Tip: Use the same email you want on deploy receipts and support tickets.

  2. Choose a deploy tier

    Pick Standard ($100), Distribution ($200), Enterprise ($500), or TestnetFree ($0). TestnetFree uses identical bytecode to mainnet — ideal for learning how to create your own crypto token before spending funds.

    Tip: Paying with PLX Token grants 50% off the one-off deploy fee; received PLX is burned.

  3. Customize token metadata

    Set name, symbol, decimals (9 is the TON convention), total supply, logo (PNG/SVG), and optional description. These fields are written into TEP-64 on-chain metadata at deploy — plan them carefully.

    Tip: Square logo ≤1024px helps Tonkeeper and wallets render your token correctly.

  4. Pay (or skip on testnet)

    Mainnet tiers accept TON, PLX Token, USDT, BTC, ETH, or PayPal. Operator deploy gas is included in the tier price. TestnetFree skips payment entirely.

    Tip: Hold ≥25,000 PLX Token to waive the $10/mo dashboard fee.

  5. Connect Tonkeeper and sign deploy

    Connect your wallet with TON Connect, confirm the deploy transaction, and Phalanx broadcasts audited JettonMinter + JettonWallet contracts (Tolk via Acton) to TON/GRAM.

    Tip: Never share your 24-word seed phrase — only approve the deploy transaction in Tonkeeper.

  6. Verify and operate

    Receive Tonviewer link, dashboard access, and audit packet. Your token is live — list on Ston.fi, submit to Tonkeeper assets, and share your minter address with holders.

    Tip: PLX Token on plx.foundation is the reference Jetton deployed with the same toolchain.

Why Phalanx Toolkit for TON/GRAM Jettons?

  • No-code browser wizard — not a generic dev toolkit, but a tokenization deployer for Jettons.
  • Audit-first Tolk contracts (JettonMinter, JettonWallet, TeamVesting) with Acton 60/60 test suite.
  • Same bytecode testnet → mainnet; free TestnetFree tier to practice.
  • Open-source contracts: github.com/phalanx-foundation/plx-token
  • PLX-86 AI assistant for token design questions inside the product.

Frequently asked questions

  • Use Phalanx Toolkit at plx.foundation: sign in, pick a tier, customize Jetton metadata, pay (or use free testnet), connect Tonkeeper, and sign the deploy transaction. Phalanx publishes audited TEP-74 contracts on the TON/GRAM Blockchain.
  • Jetton is the fungible token standard on TON/GRAM (TEP-74), similar to ERC-20 on Ethereum. Phalanx Toolkit deploys Jetton minter and wallet contracts — not ERC-20 on other chains.
  • Yes — any fungible token metadata you define (name, symbol, supply) can be deployed as a Jetton. You are responsible for compliance, liquidity, and community trust.
  • No. Phalanx ships audited Tolk contracts. You configure metadata and supply; the deploy wizard handles compilation and on-chain deployment via Acton.
  • TestnetFree is $0. Mainnet: Standard $100, Distribution $200, Enterprise $500 USD (deploy gas bundled). PLX Token payment cuts the deploy fee by 50%.
  • TON is transitioning to GRAM. Phalanx uses TON/GRAM Blockchain in public copy so citations stay accurate before and after the rename.

Ready to deploy?

Review the pre-deploy checklist, then start the wizard when your Tonkeeper wallet is ready.

Pre-deploy checklist →Pricing & tiers →Start deploy wizard →Open-source contracts →