How to create a jetton with Acton

curl -LsSf https://ton.org/acton/install.sh | sh

acton --version

acton new my-jetton --template jetton --agents

cd my-jetton

cp .env.example .env

# Name
JETTON_NAME="My new token"

# Ticker, like USDT
JETTON_SYMBOL="SAMPLE"

# Description
JETTON_DESCRIPTION="Sample jetton created with Acton"

# Use an image URL that will remain available after deployment!
JETTON_IMAGE="https://example.com/sample-jetton.png"

# Decimal precision: Gram uses 9 (nanograms), USDT uses 6 (microUSDT)
JETTON_DECIMALS="6"

# (optional) API key for mainnet
TONCENTER_MAINNET_API_KEY=...

# (optional) API key for testnet
TONCENTER_TESTNET_API_KEY=...

acton build

acton test

acton run deploy-emulation

JETTON MINTER_ADDRESS=<JETTON_MINTER_ADDRESS>
JETTON TOTAL_SUPPLY=0
JETTON MINTABLE=-1
JETTON ADMIN_ADDRESS=<JETTON_ADMIN_ADDRESS>
JETTON METADATA_name=<JETTON_NAME>
JETTON METADATA_symbol=<JETTON_SYMBOL>

acton run deploy-testnet --explorer tonscan --tonconnect

JETTON_MINTER_ADDRESS=...

acton wallet new --name deployer --version v5r1 --local --secure=true

acton wallet airdrop deployer --net testnet

acton wallet list --balance

acton run deploy-testnet --explorer tonscan

JETTON_MINTER_ADDRESS=...

acton run jetton-info --fork-net testnet

JETTON_MINT_AMOUNT=42000000 \
  acton run jetton-mint --net testnet --explorer tonscan --tonconnect

acton script scripts/deploy.tolk --net mainnet --explorer tonscan --tonconnect

JETTON_MINT_AMOUNT=42000000 \
  acton run jetton-mint --net mainnet --explorer tonscan --tonconnect

JETTON_NEW_ADMIN_ADDRESS=UQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJKZ \
  acton run jetton-change-admin --net mainnet --explorer tonscan

mkdir jetton-windows
cd jetton-windows
mkdir contracts
mkdir gen
mkdir build
mkdir scripts

git clone https://github.com/ton-blockchain/acton-contracts.git vendor\acton-contracts

Copy-Item vendor\acton-contracts\jetton-v2.1\contracts\*.tolk contracts\

npm init -y
npm install @ton/core @tonconnect/sdk qrcode-terminal
npm install --save-dev typescript tsx @ton/tolk-js

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true
  }
}

/vendor
/node_modules
.env

npx @ton/tolk-js -o build\JettonWallet.json contracts\JettonWallet.tolk

$artifact = Get-Content "build\JettonWallet.json" | ConvertFrom-Json
$artifact.codeBoc64 | Set-Content build\JettonWallet.base64

$walletCodeBase64 = Get-Content build\JettonWallet.base64

@"
// Manually generated on Windows.
// Provides compiled BoC data for the JettonWallet contract.
//
@pure
fun jettonWalletCompiledCode(): cell asm """
    "$walletCodeBase64" base64>B B>boc PUSHREF
"""
"@ | Set-Content gen\JettonWallet.code.tolk

// Replace this line
import "@gen/JettonWallet.code"

// with this line
import "../gen/JettonWallet.code"

npx @ton/tolk-js -o build\JettonMinter.json contracts\JettonMinter.tolk

$artifact = Get-Content "build\JettonMinter.json" | ConvertFrom-Json
$artifact.codeBoc64 | Set-Content build\JettonMinter.base64

import { Address, beginCell, Cell, contractAddress, Dictionary, StateInit, storeStateInit, toNano } from "@ton/core";
import TonConnect from "@tonconnect/sdk";
import { createHash } from "node:crypto";
import { readFileSync } from "node:fs";
import { createRequire } from "node:module";
import { createInterface } from "node:readline/promises";
import { stdin as input, stdout as output } from "node:process";

// Network to deploy the jettons to
const NETWORK: "testnet" | "mainnet" = "testnet";

// Initial jetton supply: 42 jettons when JETTON_DECIMALS is "6"
const INITIAL_SUPPLY = 42_000_000n;

// Jetton metadata
const JETTON_NAME = "Sample Jetton";
const JETTON_SYMBOL = "SAMPLE";
const JETTON_DESCRIPTION = "Sample jetton created on Windows";
const JETTON_IMAGE = "https://example.com/sample-jetton.png";
const JETTON_DECIMALS = "6";

// --- rest of the script ---

const NETWORK_ID = NETWORK === "mainnet" ? "-239" : "-3";
const TEST_ONLY = NETWORK === "testnet";
const MANIFEST_URL = "https://ton-connect.github.io/demo-dapp-with-wallet/tonconnect-manifest.json";

const require = createRequire(import.meta.url);
const qrcode = require("qrcode-terminal") as {
  generate(input: string, options?: { small?: boolean }): void;
};

class MemoryStorage {
  private readonly data = new Map<string, string>();

  async setItem(key: string, value: string) {
    this.data.set(key, value);
  }

  async getItem(key: string) {
    return this.data.get(key) ?? null;
  }

  async removeItem(key: string) {
    this.data.delete(key);
  }
}

function snakeData(value: string): Cell {
  return beginCell()
    .storeUint(0, 8)
    .storeStringTail(value)
    .endCell();
}

function sha256BigInt(value: string): bigint {
  return BigInt("0x" + createHash("sha256").update(value).digest("hex"));
}

function buildOnchainMetadata(): Cell {
  const entries = [
    ["name", JETTON_NAME],
    ["symbol", JETTON_SYMBOL],
    ["description", JETTON_DESCRIPTION],
    ["image", JETTON_IMAGE],
    ["decimals", JETTON_DECIMALS],
  ];

  const metadata = Dictionary.empty(Dictionary.Keys.BigUint(256), Dictionary.Values.Cell());
  for (const [key, value] of entries) {
    metadata.set(sha256BigInt(key), snakeData(value));
  }

  return beginCell()
    .storeUint(0, 8)
    .storeDict(metadata)
    .endCell();
}

function buildMinterData(adminAddress: Address): Cell {
  return beginCell()
    .storeCoins(0n)
    .storeAddress(adminAddress)
    .storeAddress(null)
    .storeRef(buildOnchainMetadata())
    .endCell();
}

function buildTopUpBody(): string {
  return beginCell()
    .storeUint(0xd372158c, 32) // TopUpTons
    .endCell()
    .toBoc()
    .toString("base64");
}

function buildMintBody(adminAddress: Address): string {
  const forwardPayload = beginCell()
    .storeUint(0, 32)
    .storeStringTail("Initial mint")
    .endCell();

  const internalTransfer = beginCell()
    .storeUint(0x178d4519, 32) // InternalTransferStep
    .storeUint(0n, 64)
    .storeCoins(INITIAL_SUPPLY)
    .storeAddress(null) // transferInitiator: null when minting
    .storeAddress(adminAddress) // sendExcessesTo
    .storeCoins(toNano("0.02"))
    .storeBit(1) // forwardPayload stored as a reference
    .storeRef(forwardPayload)
    .endCell();

  return beginCell()
    .storeUint(0x642b7d07, 32) // MintNewJettons
    .storeUint(0n, 64)
    .storeAddress(adminAddress)
    .storeCoins(toNano("0.08")) // Gram sent to the admin's jetton wallet
    .storeRef(internalTransfer)
    .endCell()
    .toBoc()
    .toString("base64");
}

async function connectWallet(connector: TonConnect) {
  await connector.restoreConnection();
  if (connector.wallet) {
    return connector.wallet;
  }

  const wallets = (await connector.getWallets())
    .filter((wallet: any) => wallet.bridgeUrl && wallet.universalLink);

  if (wallets.length === 0) {
    throw new Error("No TON Connect wallets with bridge support were found.");
  }

  wallets.slice(0, 10).forEach((wallet: any, index: number) => {
    console.log(`${index + 1}. ${wallet.name}`);
  });

  const rl = createInterface({ input, output });
  const answer = await rl.question("Select wallet [1]: ");
  rl.close();

  const selectedIndex = Math.min(wallets.length - 1, Math.max(0, Number(answer || "1") - 1));
  const selected = wallets[selectedIndex] as any;
  const universalLink = connector.connect({
    bridgeUrl: selected.bridgeUrl,
    universalLink: selected.universalLink,
  });

  console.log(`\nScan this QR code with ${selected.name}, or open the link below:\n`);
  qrcode.generate(universalLink, { small: true });
  console.log(`\n${universalLink}\n`);

  return await new Promise<NonNullable<typeof connector.wallet>>((resolve, reject) => {
    let unsubscribe: (() => void) | undefined;
    const timeout = setTimeout(() => {
      unsubscribe?.();
      reject(new Error("Wallet connection timed out."));
    }, 180_000);

    unsubscribe = connector.onStatusChange((wallet) => {
      if (!wallet) {
        return;
      }
      clearTimeout(timeout);
      unsubscribe?.();
      resolve(wallet);
    }, reject);
  });
}

async function main() {
  const connector = new TonConnect({
    manifestUrl: MANIFEST_URL,
    storage: new MemoryStorage(),
  });
  const wallet = await connectWallet(connector);

  if (wallet.account.chain !== NETWORK_ID) {
    throw new Error(`Switch the connected wallet to ${NETWORK}.`);
  }

  const sendFeature = wallet.device.features.find(
    (feature: any) => typeof feature === "object" && feature.name === "SendTransaction"
  ) as { maxMessages?: number } | undefined;
  if (sendFeature?.maxMessages !== undefined && sendFeature.maxMessages < 2) {
    throw new Error("The connected wallet does not support sending both deploy and mint messages together.");
  }

  const adminAddress = Address.parse(wallet.account.address);
  const code = Cell.fromBase64(readFileSync("build/JettonMinter.base64"));
  const data = buildMinterData(adminAddress);
  const stateInit: StateInit = { code, data };
  const minterAddress = contractAddress(0, stateInit);

  const minterDeployAddress = minterAddress.toString({ testOnly: TEST_ONLY, bounceable: false });
  const minterMintAddress = minterAddress.toString({ testOnly: TEST_ONLY, bounceable: true });
  const stateInitBoc = beginCell()
    .store(storeStateInit(stateInit))
    .endCell()
    .toBoc()
    .toString("base64");

  console.log("Network:", NETWORK);
  console.log("Admin wallet:", adminAddress.toString({ testOnly: TEST_ONLY }));
  console.log("Jetton minter:", minterAddress.toString({ testOnly: TEST_ONLY }));
  console.log("Initial supply:", INITIAL_SUPPLY.toString(), "elementary units");
  console.log("Approve the deploy and mint transaction in the wallet.");

  await connector.sendTransaction({
    validUntil: Math.floor(Date.now() / 1000) + 600,
    network: NETWORK_ID,
    from: wallet.account.address,
    messages: [
      {
        address: minterDeployAddress,
        amount: toNano("0.05").toString(),
        stateInit: stateInitBoc,
        payload: buildTopUpBody(),
      },
      {
        address: minterMintAddress,
        amount: toNano("0.15").toString(),
        payload: buildMintBody(adminAddress),
      },
    ],
  });

  console.log("Transaction sent.");
  console.log("Jetton minter:", minterAddress.toString({ testOnly: TEST_ONLY }));
}

main().catch((error) => {
  console.error(error);
  process.exit(1);
});

npx tsx scripts\deploy.ts

const NETWORK: "testnet" | "mainnet" = "mainnet";