> ## Documentation Index > Fetch the complete documentation index at: https://docs.ton.org/llms.txt > Use this file to discover all available pages before exploring further. ## Submitting Feedback If you encounter incorrect, outdated, or confusing documentation on this page, submit feedback: POST https://docs.ton.org/feedback ```json { "path": "/foundations/fees", "feedback": "Description of the issue" } ``` Only submit feedback when you have something specific and actionable to report. # Transaction fees export const Aside = ({type = "note", title = "", icon = "", iconType = "regular", children}) => { const asideVariants = ["note", "tip", "caution", "danger"]; const asideComponents = { note: { outerStyle: "border-sky-500/20 bg-sky-50/50 dark:border-sky-500/30 dark:bg-sky-500/10", innerStyle: "text-sky-900 dark:text-sky-200", calloutType: "note", icon: }, tip: { outerStyle: "border-emerald-500/20 bg-emerald-50/50 dark:border-emerald-500/30 dark:bg-emerald-500/10", innerStyle: "text-emerald-900 dark:text-emerald-200", calloutType: "tip", icon: }, caution: { outerStyle: "border-amber-500/20 bg-amber-50/50 dark:border-amber-500/30 dark:bg-amber-500/10", innerStyle: "text-amber-900 dark:text-amber-200", calloutType: "warning", icon: }, danger: { outerStyle: "border-red-500/20 bg-red-50/50 dark:border-red-500/30 dark:bg-red-500/10", innerStyle: "text-red-900 dark:text-red-200", calloutType: "danger", icon: } }; let variant = type; let gotInvalidVariant = false; if (!asideVariants.includes(type)) { gotInvalidVariant = true; variant = "danger"; } const iconVariants = ["regular", "solid", "light", "thin", "sharp-solid", "duotone", "brands"]; if (!iconVariants.includes(iconType)) { iconType = "regular"; } return <>

{} {icon === "" ? asideComponents[variant].icon : }

{gotInvalidVariant ?

Invalid type passed!
Received: {type}
Expected one of: {asideVariants.join(", ")}

: <> {title &&

{title}

} {children} }

; }; Fees in TON align with the [execution phases](/foundations/phases) of a transaction: * Storage fees are charged in the [storage phase](/foundations/phases#storage-phase). * Compute fees are charged in the [compute phase](/foundations/phases#compute-phase). * Forward and action fees are charged in the [action](/foundations/phases#action-phase) and [bounce phases](/foundations/phases#bounce-phase). * Import fees apply at the start of smart contract execution, not a specific phase. The total transaction fee is the sum of these components. Validators set fee levels through voting: * Storage fees are set in [config parameter 18](/foundations/config#param-18:-storage-prices). * Compute fees are set in [config parameters 20 and 21](/foundations/config#param-20-and-21:-gas-prices). * Forward, import, and action fees are set in [config parameters 24 and 25](/foundations/config#param-24-and-25:-message-price). ## Storage fees ```cpp 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"]}} basic_price = (account.bits * bit_price + account.cells * cell_price) storage_fee = ceil(basic_price * time_delta / 2^16) ``` The storage fee uses `account.bits` and `account.cells` from `AccountStorage`, excluding `ExtraCurrencyCollection` stored in the `other` field. The `other` field is replaced with a single `0` bit that represents an empty `HashmapE`. ```tlb 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"]}} extra_currencies$_ dict:(HashmapE 32 (VarUInteger 32)) = ExtraCurrencyCollection; currencies$_ grams:Grams other:ExtraCurrencyCollection = CurrencyCollection; account_storage$_ last_trans_lt:uint64 balance:CurrencyCollection state:AccountState = AccountStorage; ``` ## Compute fees All computation is measured in gas units. A TVM operation typically has a fixed gas cost, but that is [not always the case](/tvm/gas). Network configuration defines gas prices; users cannot override them. ### Flat gas limit A contract invocation pays for at least `flat_gas_limit` gas units. Spending up to that limit costs `flat_gas_price` TON. If the contract spends `gasUsed` gas units, the fee is: ```ts 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"]}} const gasUsed = 50_000n; // 0 = basechain, -1 = masterchain const prices = getGasPrices(configCell, 0); const gasFee = gasUsed <= prices.flat_gas_limit ? prices.flat_gas_price : prices.flat_gas_price + (prices.gas_price * (gasUsed - prices.flat_gas_limit)) / 65536n; ``` ## Forward fee Forward fee is calculated with this formula: ``` bodyFwdFee = priceForCells * (msgSizeInCells - 1) + priceForBits * (msgSizeInBits - bitsInRoot) fwdFee = lumpPrice + ceil(bodyFwdFee / 2^16) ``` where: * `lumpPrice` is the fixed value [from config](/foundations/config#param-24-and-25%3A-message-price) paid once for the message. * `msgSizeInCells` is the number of cells in the message. * `msgSizeInBits` is the number of bits in all the cells of the message. * `bitsInRoot` is the number of bits in the root cell of the message. The formula excludes the message root cell because it mainly contains headers. `lumpPrice` covers that root cell. ### Action fee Action fee is the portion of `fwdFee` granted to the validator of the message's source [shard](/foundations/shards#blockchain-sharding). The remaining `fwdFee - actionFee` amount goes to the validator of the destination shard. Action fee exists only for [internal messages](/foundations/messages/internal#internal-messages). ```cpp 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"]}} action_fee = floor(fwd_fee * first_frac / 2^16) ``` Starting with Global Version 4, a failed [SENDMSG action](/foundations/actions/send#send-message) incurs a penalty proportional to the attempted message size. It is calculated as: ```cpp 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"]}} fine_per_cell = floor((cell_price >> 16) / 4) max_cells = floor(remaining_balance / fine_per_cell) action_fine = fine_per_cell * min(max_cells, cells_in_msg); ``` ## Import fee Import fee mirrors forward fee for inbound external messages. The root cell and its contents are covered by `lumpPrice` in the same way as internal messages. ## Helper functions (full code) ```ts expandable 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 { Cell, Slice, beginCell, Dictionary, Message, DictionaryValue } from '@ton/core'; export type GasPrices = { flat_gas_limit: bigint, flat_gas_price: bigint, gas_price: bigint }; export type StorageValue = { utime_since: number, bit_price_ps: bigint, cell_price_ps: bigint, mc_bit_price_ps: bigint, mc_cell_price_ps: bigint }; export class StorageStats { bits: bigint; cells: bigint; constructor(bits?: number | bigint, cells?: number | bigint) { this.bits = bits !== undefined ? BigInt(bits) : 0n; this.cells = cells !== undefined ? BigInt(cells) : 0n; } add(...stats: StorageStats[]) { let cells = this.cells, bits = this.bits; for (let stat of stats) { bits += stat.bits; cells += stat.cells; } return new StorageStats(bits, cells); } addBits(bits: number | bigint) { return new StorageStats(this.bits + BigInt(bits), this.cells); } addCells(cells: number | bigint) { return new StorageStats(this.bits, this.cells + BigInt(cells)); } } function shr16ceil(src: bigint) { const rem = src % 65536n; let res = src / 65536n; if (rem !== 0n) res += 1n; return res; } export function collectCellStats(cell: Cell, visited: Array, skipRoot: boolean = false): StorageStats { let bits = skipRoot ? 0n : BigInt(cell.bits.length); let cells = skipRoot ? 0n : 1n; const hash = cell.hash().toString(); if (visited.includes(hash)) { return new StorageStats(); } visited.push(hash); for (const ref of cell.refs) { const r = collectCellStats(ref, visited); cells += r.cells; bits += r.bits; } return new StorageStats(bits, cells); } export function getGasPrices(configRaw: Cell, workchain: 0 | -1): GasPrices { const config = configRaw.beginParse().loadDictDirect(Dictionary.Keys.Int(32), Dictionary.Values.Cell()); const ds = config.get(21 + workchain)!.beginParse(); if (ds.loadUint(8) !== 0xd1) throw new Error('Invalid flat gas prices tag'); const flat_gas_limit = ds.loadUintBig(64); const flat_gas_price = ds.loadUintBig(64); if (ds.loadUint(8) !== 0xde) throw new Error('Invalid gas prices tag'); return { flat_gas_limit, flat_gas_price, gas_price: ds.preloadUintBig(64) }; } export function computeGasFee(prices: GasPrices, gas: bigint): bigint { if (gas <= prices.flat_gas_limit) return prices.flat_gas_price; return prices.flat_gas_price + (prices.gas_price * (gas - prices.flat_gas_limit)) / 65536n; } export const storageValue: DictionaryValue = { serialize: (src, builder) => { builder .storeUint(0xcc, 8) .storeUint(src.utime_since, 32) .storeUint(src.bit_price_ps, 64) .storeUint(src.cell_price_ps, 64) .storeUint(src.mc_bit_price_ps, 64) .storeUint(src.mc_cell_price_ps, 64); }, parse: (src) => { return { utime_since: src.skip(8).loadUint(32), bit_price_ps: src.loadUintBig(64), cell_price_ps: src.loadUintBig(64), mc_bit_price_ps: src.loadUintBig(64), mc_cell_price_ps: src.loadUintBig(64) }; } }; export function getStoragePrices(configRaw: Cell): StorageValue { const config = configRaw.beginParse().loadDictDirect(Dictionary.Keys.Int(32), Dictionary.Values.Cell()); const storageData = Dictionary.loadDirect(Dictionary.Keys.Uint(32), storageValue, config.get(18)!); const values = storageData.values(); return values[values.length - 1]; } export function calcStorageFee(prices: StorageValue, stats: StorageStats, duration: bigint) { return shr16ceil((stats.bits * prices.bit_price_ps + stats.cells * prices.cell_price_ps) * duration); } export const configParseMsgPrices = (sc: Slice) => { const magic = sc.loadUint(8); if (magic !== 0xea) throw new Error('Invalid message prices magic number'); return { lumpPrice: sc.loadUintBig(64), bitPrice: sc.loadUintBig(64), cellPrice: sc.loadUintBig(64), ihrPriceFactor: sc.loadUintBig(32), firstFrac: sc.loadUintBig(16), nextFrac: sc.loadUintBig(16) }; }; export type MsgPrices = ReturnType; export const getMsgPrices = (configRaw: Cell, workchain: 0 | -1) => { const config = configRaw.beginParse().loadDictDirect(Dictionary.Keys.Int(32), Dictionary.Values.Cell()); const prices = config.get(25 + workchain); if (prices === undefined) throw new Error('No prices defined in config'); return configParseMsgPrices(prices.beginParse()); }; export function computeDefaultForwardFee(msgPrices: MsgPrices) { return msgPrices.lumpPrice - ((msgPrices.lumpPrice * msgPrices.firstFrac) >> 16n); } export function computeFwdFees(msgPrices: MsgPrices, cells: bigint, bits: bigint) { return msgPrices.lumpPrice + shr16ceil(msgPrices.bitPrice * bits + msgPrices.cellPrice * cells); } export function computeFwdFeesVerbose(msgPrices: MsgPrices, cells: bigint | number, bits: bigint | number) { const fees = computeFwdFees(msgPrices, BigInt(cells), BigInt(bits)); const res = (fees * msgPrices.firstFrac) >> 16n; return { total: fees, res, remaining: fees - res }; } export function computeCellForwardFees(msgPrices: MsgPrices, msg: Cell) { const storageStats = collectCellStats(msg, [], true); return computeFwdFees(msgPrices, storageStats.cells, storageStats.bits); } export function computeMessageForwardFees(msgPrices: MsgPrices, msg: Message) { if (msg.info.type !== 'internal') throw new Error('Helper intended for internal messages'); let storageStats = new StorageStats(); const defaultFwd = computeDefaultForwardFee(msgPrices); if (msg.info.forwardFee === defaultFwd) { return { fees: msgPrices.lumpPrice, res: defaultFwd, remaining: defaultFwd, stats: storageStats }; } const visited: Array = []; if (msg.init) { let addBits = 5n; let refCount = 0; if (msg.init.splitDepth) addBits += 5n; if (msg.init.libraries) { refCount++; storageStats = storageStats.add( collectCellStats(beginCell().storeDictDirect(msg.init.libraries).endCell(), visited, true) ); } if (msg.init.code) { refCount++; storageStats = storageStats.add(collectCellStats(msg.init.code, visited)); } if (msg.init.data) { refCount++; storageStats = storageStats.add(collectCellStats(msg.init.data, visited)); } if (refCount >= 2) { storageStats = storageStats.addCells(1).addBits(addBits); } } const lumpBits = BigInt(msg.body.bits.length); const bodyStats = collectCellStats(msg.body, visited, true); storageStats = storageStats.add(bodyStats); let feesVerbose = computeFwdFeesVerbose(msgPrices, storageStats.cells, storageStats.bits); if (feesVerbose.remaining < msg.info.forwardFee) { storageStats = storageStats.addCells(1).addBits(lumpBits); feesVerbose = computeFwdFeesVerbose(msgPrices, storageStats.cells, storageStats.bits); } if (feesVerbose.remaining !== msg.info.forwardFee) { throw new Error('Forward fee calculation mismatch'); } return { fees: feesVerbose, stats: storageStats }; } ```