TON/GRAM BLOCKCHAIN • WEB TOKENIZATION • ACTON • NO-CODE

Build your dream token.No code. No CLI.

Name: Phalanx Toolkit
Author: Phalanx Foundation

Pick an audited template, or describe your token to PLX-86 Assist in plain language. We sign, deploy, and verify on-chain — rehearse on the TON testnet sandbox first, then promote to mainnet when you are ready.

Build my token See templates

See PLX — our reference deployment →

~/phalanx ·install acton

$ curl -LsSf https://github.com/ton-blockchain/acton/releases/latest/download/acton-installer.sh | sh

Then `acton build && acton test` — same contracts that run PLX testnet.

Acton

Test-suite optimized

Securely

Token deploy process

No skill

Coding required

Flex-custom

Auto-audit included

Start from a template

Pick a contract that already works.

Don't have a clear idea yet? Start from one of our battle-tested templates. Each one is open-source, passes 60/60 Acton tests, and is ready to deploy in minutes — just fill in the name, supply, and distribution. No coding required.

Already have something custom in mind? Describe it in plain language and our AI will write the smart contract for you to review.

Six glowing smart contract template cards arranged in a grid

audited

Standard Jetton

Versatile fungible token — safest default.

Audited TON jetton pattern (mint/transfer/burn) from plx-token. For utility, community, or rewards where you do not need special distribution logic.

Use this template →

audited

Distribution Jetton

Transparent allocations — not opaque insider dumps.

Jetton suited to documented airdrops, team buckets, and treasury splits with public cap tables and multisig — not for hidden one-sided profit extraction.

Use this template →

audited

Burnable Jetton

On-chain deflation — irreversible burn only.

Jetton with permanent burn for disclosed fee recycling, buyback-and-burn, or consumable game items — not as a disguise for team exits.

Use this template →

audited

Capped Supply

Hard supply cap — no inflation.

Jetton with a maximum supply; extra minting disabled after deploy. Strongest default for public trust when you will not need more inflation.

Use this template →

audited

NFT Collection

Unique items — decimals 0.

NFT / SBT on TON: each item is unique, not a fractional fungible traded as a security narrative.

Use this template →

AI-built

Custom · Reviewed build

Non-standard ideas — manual review required (beta).

Experimental path: Phalanx reviews parameters before mainnet. We do not deploy honeypots, hidden taxes, impersonation clones, or opaque owner privileges.

Use this template →

PLX-86 Assist

Have an idea? Describe it in your own words.

You don't need to know what a Jetton is, what gas means, or how Tolk works. Just describe what you want your token to do. PLX-86 Assist translates it into audited smart-contract code — and you stay in control of the review and the keys.

Phalanx AI translates a natural-language prompt into Tolk smart-contract code

Try the AI PLX-86 Assist

Try the AI PLX-86 Assist →See full flow

PLX-86 Assist

● online

click to pause

01Describe
Type what you want in your own words. Example: "A token where 5% of every transfer goes to a charity wallet, with a hard supply of 100 million."
02AI drafts
PLX-86 Assist writes the Tolk smart contract + matching unit tests. You see the source, not a black box.
03Audit review
Auto-flags red flags (admin escape hatches, unbounded loops, gas issues). Ask PLX-86 Assist to revise — or accept the draft.
04Sign & deploy
We sign, broadcast, and verify the contract on Tonviewer. You own the keys, we never custody.

Platform fit

Built for teams shipping real products — not just contracts

The same ideas behind modern TON tooling — dApp integration, agent-friendly workflows, safe rehearsal, and verifiable output — packaged as a no-code launch path on top of audited Acton + Tolk contracts.

From product to dApp

Plug into your existing app

Already shipping a web or mobile app? Add a TON jetton layer with TypeScript wrappers and TON Connect — your users keep the same UX while balances and transfers move on-chain.

Hermes · OpenClaw · your stack

AI agents & automations

PLX-86 Assist and the same audited deploy surface humans use are built for agents: structured scripts, predictable metadata, and review gates before anything hits mainnet.

Try everything — risk-free

Sandbox on TON testnet

Every launch rehearses on testnet first: identical bytecode, real wallet flows, and Tonviewer proofs. When stakeholders sign off, promote to mainnet — no surprise diffs.

Audit trail, not vibes

Full analysis packet

60/60 Acton tests, open Tolk source, Tonviewer verification, cap-table receipts, and dashboard exports — the complete report investors and partners expect.

How it works

From sign-up to mainnet in six honest steps.

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

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

 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 →

Step 1 of 6

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

Token archetypes

Designed for the tokens you want to ship.

A snapshot of the categories the toolkit is built to deploy — from loyalty and treasury tokens to vesting-locked DAO assets. Real launches will be listed here as they go live.

AUR

VKR

MOR

FLX

ION

ECH

TLR

STR

QNT

DRP

ARC

AUR

VKR

MOR

FLX

ION

ECH

TLR

STR

QNT

DRP

ARC

Why Phalanx

Built for people who don't want to get rugged.

The TON ecosystem has too many deployers that hide what they're shipping. Phalanx is the opposite: the contract is the product, the tests are public, and you sign every transaction.

60/60 tests passing

Every contract template ships with a unit-test suite that runs on Acton. No surprise bugs, no hidden behavior.

Audit-first, no proxies

You can read the entire smart contract before you sign. No upgradeable proxies, no admin escape hatches, no centralized JSON metadata.

0 code, ≤5 minutes

Pay any way you want

TON, PLX (50% off), USDT, BTC, ETH, and PayPal. Direct credit-card checkout lands shortly after backend launch. We cover the operator gas — you pay one flat amount.

PLX-86 Assist included

Don't know how to write a smart contract? Just describe what you want in English. PLX-86 Assist writes audit-ready Tolk for you.

100% open source

Every contract, every wrapper, every script is on GitHub. You can audit, fork, and run it yourself. No black box.

Who it's for

Built for the people actually shipping tokens on TON.

Whether you're a solo founder, a community treasury, an app team wiring TON into an existing product, or a Web3 agency — Phalanx packages audited contracts, sandbox testnet rehearsal, and on-chain proof so you focus on the business, not the bytecode.

Solo founders

Launch a token without hiring a team

You have an idea, an audience, and zero budget for a Solidity dev. Pick a template, fill the form, deploy. Done in an afternoon.

Communities & DAOs

Distribute fairly, lock the team

Use the Distribution template — vesting is enforced on-chain at deploy time. The team can't dump because the contract physically won't let them.

App & product teams

Turn your app into a dApp

You already have users and a product roadmap. Add a jetton layer with TON Connect and generated wrappers — PLX-86 Assist or your own agent can drive the same deploy flow.

Web3 agencies

White-label deployments for your clients

You handle a portfolio of token launches. We handle the contracts, tests, and audits. You charge your client and pocket the difference.

What the toolkit ships

Smart contract operations, without the foot-guns

Phalanx isn't another deployer UI on top of an unread contract. It is the contract — exposed, tested, and operated through Acton.

Audited Tolk contracts

JettonMinter, JettonWallet, TeamVesting — 60/60 Acton tests, gas-bounded, bounce-safe, TEP-74 + TEP-89 compliant.

On-chain metadata cell

Name, ticker, decimals, image — encoded TEP-64 dictionary so wallets like Tonkeeper render correctly without a centralized JSON.

Linear vesting, immutable

TeamVesting locks supply at deploy time. No upgradeable proxies, no admin escape hatch — just claim(now) against a sealed schedule.

Analysis & verification packet

Every deploy includes test results, Tonviewer proof, GitHub source links, and dashboard exports — the due-diligence pack partners and investors expect.

Agent-ready scripts

Every operator action is a Tolk script with deterministic args. AI agents can ship a Jetton through the same surface a human uses.

Testnet → mainnet, identical bytecode

PLX testnet is a full-fidelity rehearsal: same compiler, same storage layout, same wrappers. Mainnet promotion is just a network flag.

Open source

Read the actual contracts before you sign.

Every template ships as audited Tolk — JettonMinter, JettonWallet, TeamVesting. Browse the source, run Acton tests locally, then deploy through the same bytecode path we use for PLX.

contracts/JettonMinter.tolk

// Tolk — operations the minter accepts on TON
fun handleInternal(
  msg: cell,
  sender: address,
  body: slice
): void {
  val op = body.loadOp();
  match (op) {
    op::mint => doMint(body, sender);
    op::transferAdmin => doTransferAdmin(body, sender);
    op::changeContent => doChangeContent(body, sender);
    op::dropAdmin => doDropAdmin(sender);
    else => throw error::unknownOp;
  }
}

Read full source on GitHubView raw →

Extra depth

More than the happy path

ComplianceTerms & securityPre-launch legal framework and coordinated disclosure policy.Read more →PricingToolkit tiersStandard, Distribution, and Enterprise tiers with full FAQ.Read more →PLX utilityPay with PLX, save 50%Reference token, payment medium, burned at receipt on payment.Read more →CIGitHub ActionsBuild, test, and signed commits in the pipeline you control.Read more →

Why trust Phalanx

Built by operators who ship on-chain — not slide decks

Phalanx Foundation publishes audited smart contracts, runs the same deploy path you use, and proves every mainnet claim with public repos and explorer links.

Experience

We deploy what we sell

PLX Token is our live reference Jetton on the TON/GRAM Blockchain — deployed with the same Phalanx Toolkit wizard, Tonviewer verification, and mainnet operations you get as a customer.

Reference token: PLX Token · same bytecode testnet → mainnet path

Expertise

Audit-first Tolk + Acton

JettonMinter, JettonWallet, and TeamVesting ship with 60/60 Acton unit tests, TEP-74/TEP-64 compliance, and readable Tolk source — no upgradeable proxy templates on standard tiers.

Open source: github.com/phalanx-foundation/plx-token

Authoritativeness

Phalanx Foundation on TON/GRAM

Independent infrastructure team focused on Web3 crypto tokenization — tooling, PLX Token economics, and agent-ready Acton scripts cited by partners and builders in the ecosystem.

Publisher: Phalanx Foundation · plx.foundation

Trustworthiness

You sign every transaction

No custodial deploy keys. Transparent pricing, published Terms and Security policy, responsible disclosure channel, and on-chain receipts — contracts keep running even if you cancel the dashboard.

Security · Terms · Contact — all on plx.foundation

Read our story & credentials →Security & disclosure →

Subscriptions plan

Burn your money, for token deploy.

Two parts, no surprises: a one-off build & deploy fee for the contract going on-chain, then a small monthly subscription that keeps your dashboard, audit reports, on-chain activity feed, and concierge support online. Cancel any time and your contract still runs — you own the keys.

On-chain gas is on us. You pay the flat tier price — we handle every blockchain fee.

Standard

Single Jetton, audited.

$100to build & deploy

Or 20 TON · 10 PLX (-50%)

+ monthly subscription

$10 / monthFree while you hold 25,000 PLX

Keeps dashboard, on-chain feed, audit reports & support running. Free with 25,000 PLX hold; otherwise $10/month.

JettonMinter + JettonWallet (audited Tolk)
Token dashboard with on-chain proof
Tonviewer verification + GitHub source link
Mintable / burnable toggles
Email support · 48h response
Mainnet upgrade path (testnet → mainnet, identical bytecode)

Distribution

Vesting + multi-wallet rollout.

$200to build & deploy

Or 40 TON · 20 PLX (-50%)

+ monthly subscription

$10 / monthFree while you hold 25,000 PLX

Keeps dashboard, on-chain feed, audit reports & support running. Free with 25,000 PLX hold; otherwise $10/month.

Everything in Standard, plus —
Linear vesting (TeamVesting, immutable)
Bulk distribution (CSV up to 5,000 wallets)
Cliff + duration scheduling
Priority deploy queue (≤10 min mainnet)
Concierge audit walkthrough (1 session)
Slack / Telegram support · 24h response

Enterprise

Custom contracts, SLA, dedicated team.

$500to build & deploy

Or 100 TON · 50 PLX (-50%)

+ monthly subscription

$10 / monthFree while you hold 25,000 PLX

Keeps dashboard, on-chain feed, audit reports & support running. Free with 25,000 PLX hold; otherwise $10/month.

Everything in Distribution, plus —
Custom contract modules (we co-author the Tolk)
External auditor coordination included
Dedicated deployment engineer
99.9% dashboard SLA · status page
Compliance pack (audit reports, source archive)
Custom integrations (Telegram bot, webhooks, RPC)

TON testnet

Testnet Free

Try free on testnet.

Freeto build & deploy

Standard jetton on TON testnet — $0
Connect wallet — you stay in control of admin keys
Customize name, symbol, supply & metadata
Real broadcast deploy (not simulated)
Tonviewer link + GitHub audited source
Minimal dashboard with minter address
No template pick · no payment step
Mainnet upgrade when you choose a paid tier

+ monthly subscription

FREE 100%

Full premium dashboard & analytics when you upgrade to a paid tier and hold 25,000 PLX.

See full pricing & FAQ →What to prepare before deploy →

Front-line Phalanx Shield Discount

Get a discount as one of our first 50 token owners.

Among the first fifty operators to deploy through Phalanx Toolkit? You get the launch discount — pay with PLX and we cut another 50% off, then burn the PLX you paid at the contract level. Direct fee burn, fully on-chain.

View pricing

Build your dream token.No code. No CLI.

Pick a contract that already works.

Standard Jetton

Distribution Jetton

Burnable Jetton

Capped Supply

NFT Collection

Custom · Reviewed build

Have an idea? Describe it in your own words.

Built for teams shipping real products — not just contracts

Plug into your existing app

AI agents & automations

Sandbox on TON testnet

Full analysis packet

From sign-up to mainnet in six honest steps.

Designed for the tokens you want to ship.

Built for people who don't want to get rugged.

60/60 tests passing

Audit-first, no proxies

0 code, ≤5 minutes

Pay any way you want

PLX-86 Assist included

100% open source

Built for the people actually shipping tokens on TON.

Solo founders

Communities & DAOs

App & product teams

Web3 agencies

Smart contract operations, without the foot-guns

Audited Tolk contracts

On-chain metadata cell

Linear vesting, immutable

Analysis & verification packet

Agent-ready scripts

Testnet → mainnet, identical bytecode

Read the actual contracts before you sign.

More than the happy path

Built by operators who ship on-chain — not slide decks

We deploy what we sell

Audit-first Tolk + Acton

Phalanx Foundation on TON/GRAM

You sign every transaction

Burn your money, for token deploy.

Standard

Distribution

Enterprise

Testnet Free

Get a discount as one of our first 50 token owners.

The TON ecosystem we ship into.