Changelog

• The estimate service is running on mainnet. pharpc1, pharpc2 and pharpc3 all answer estimateTransaction.
• Send a node a serialized transaction and it runs that transaction against current chain state without broadcasting it. The answer carries the gas bill, the storage rows the transaction would create, the deposit and the refund, and the maxGas and maxData to sign it with.
• The signatures inside the transaction you send can be zero-filled dummies of the right length. The dry run skips signature checks, and the dummies keep the byte length the bill depends on, so a wallet can show the fee before it asks anyone to sign.
• The answer also says whether the transaction would fail, and why. A transfer from an account short of KCAL comes back with the reason and with both amounts, what it holds and what the fee needs.
• Contract calls are estimated the same way as any other transaction, and the public nodes answer contract reads as well, so a tool can price a call and read its result from the same node.
• The SDKs also calculate a fee on their own, with no round trip, and that covers transfers, mints, burns and token creation. The node estimate is useful primarily for contract calls because their price depends on what the code does when it runs, and the estimator runs it and provides the real fees consumed by the call.

• Published latest versions: phantasma-sdk-ts 0.18.0, phantasma-sdk-py 4.0.0, phantasma-sdk 3.0.0 (Rust), phantasma-sdk-go v0.18.0, PhantasmaPhoenix.RPC 0.16.0, PhantasmaPhoenix.NFT 0.7.14, and PhantasmaPhoenix.Link 0.3.4.
• Gas model v2 went live on mainnet on 27 August. Every transaction now names the amount it is willing to pay. The chain turns away one that offers nothing.
• Every SDK now calculates that amount. It is taken from the message, so you have the number before anything is signed.
• The SDK also says whether the amount is the price or an upper limit. Put "up to" in front of an upper limit when you show it to a user.
• Part of the price depends on details the message does not carry. The calculator takes the expensive reading for each of them, so the offer is never too small. The chain returns what the transaction does not spend.
• Building, calculating, signing and sending are now separate steps. The key can sit in memory, in a hardware wallet, or in a wallet reached over Phantasma Link. There is also one method that runs all four steps.
• A transaction takes several signatures, so one account can pay the fee for another.
• Creating a token starts with a lookup on the symbol. The chain takes the creation fee before it checks the symbol, and that fee is the largest in the model. If the symbol is already taken, the SDK stops and the fee is not spent.
• The Unity SDK core package moves to 0.13.0. One method calculates the fee, signs and sends. It can also calculate the fee without a key, for a wallet that signs elsewhere. Both come with a sample. Unity 2022.3 is now the lowest editor version it supports.
• The C++ SDK received the same work in its source repository.

phantasma-sdk-ts | phantasma-sdk-py | phantasma-sdk | phantasma-sdk-go | PhantasmaPhoenix.RPC | PhantasmaPhoenix.NFT | PhantasmaPhoenix.Link | phantasma-sdk-cpp | phantasma-sdk-unity

npm install phantasma-sdk-ts@latest

pip install --upgrade phantasma-sdk-py

cargo add phantasma-sdk

go get -u github.com/phantasma-io/phantasma-sdk-go

dotnet package update PhantasmaPhoenix.RPC

dotnet package update PhantasmaPhoenix.NFT

dotnet package update PhantasmaPhoenix.Link

Mainnet finished its move to the new explorer backend on 28 August. Devnet went over in July, testnet followed in August, and mainnet came across in stages. All three networks now run the same current backend behind the same current interface.

• Pages, lists and search are served quickly even when the chain is busy.
• Rust was chosen for what it guarantees before the code runs. Entire families of failure, memory used after it is released and threads racing each other for the same data, cannot be written in it. There is no garbage collector, so response times stay steady as traffic rises. Threads are safe to use, so the same hardware answers more readers at once. Memory use stays flat across weeks of uptime.
• The new backend was built for a far heavier chain than today's. Smart contracts and sidechains will multiply the amount of data an explorer has to index and serve, and the backend was sized for that from the start, so it grows with the chain.
• The interface got better along the way. Token pages show token metadata, values the chain stores as arrays or structures are displayed in that shape, NFT attributes are built from their real structure, media hosted on IPFS loads through a gateway, payloads carrying text are shown as text, and governance calls on an event page are listed page by page.
• Every block now shows the validator that produced it, which gas model v2 made part of the block itself.

The explorer is the first Phantasma service written in Rust. A Rust validator and a Rust RPC come next.

Mainnet Explorer | Testnet Explorer | Devnet Explorer | explorer-backend | explorer-frontend

Mainnet switched to gas model v2 on 27 August. The governance resolution settled in block 9075629, and block 9075630 is the first block produced under the new rules. Devnet has run the model since July and testnet followed in August, so mainnet is the last stop of a rollout that spent two months proving itself.

• Gas is priced from measured work. The unit comes from the network's own basic operation: a plain token transfer costs 10 gas units, and everything else is priced against that. The cost of every operation the virtual machine performs was measured on the live mainnet validators, taken as medians per machine, with the slowest machine setting each number. Those measurements are frozen into the release.
• Smart contract execution is priced properly for the first time. Computation is charged by the size of the work it does. A routine contract call costs about what it always did. A script that moves large amounts of data, or runs big-number multiplication, division or exponentiation, is now billed for the size it works on.
• A transaction pays for the bytes it puts into the block, its own envelope included. The price per byte is unchanged; the envelope simply used to ride for free. This is the visible part of the reform: a script-based transfer, the shape most exchanges and older integrations send, now costs about 5x what it did.
• Everything paid in gas on mainnet is burned. Honest prices on real usage mean proportionally more KCAL leaving supply.
• Every settled bill has a floor of 0.001 KCAL, transactions that fail included, and an offer below that floor is refused before it enters the mempool.
• The mempool is ordered by what a sender commits. A higher gas offer takes an earlier place, and a full mempool makes room by dropping the lowest offer. The offer has to be backed: a validator checks that the paying account really holds it, so an account with nothing behind it can no longer occupy a place in line while real users wait.
• Keeping data on-chain now costs what permanent state is worth. A row of state escrows 0.002 SOUL, which is 100,000x the old amount and works out to about 2,000 SOUL for a full gigabyte of chain state. It stays a deposit: whoever removes the row gets back exactly what that row paid in, down to the atom, even if the price moved in between, because every paid row now carries its own escrow record. For scale, the previous generation of Phantasma locked a staked SOUL per 40 KB, about 12x more SOUL for the same amount of data, and at today's prices a gigabyte of permanent state costs about $25 here against about $720,000 on Solana.
• Sending SOUL or KCAL to an account that already holds it creates no row and no deposit, so exchange flows are untouched.
• Every block now carries the address of the validator that produced it, signed as part of the block.
• A fee can be calculated before the transaction is sent. getGasConfig publishes the live parameters, estimateTransaction prices a transaction against the current chain state, and the SDKs carry the same calculation.
• The model already holds the economics of sidechains: a share of every fee for the block producer, and a share for the application that generated it. Both ship at zero on mainnet and turn on with a single governance resolution.
• Transaction format, signatures, addresses, expiry, RPC methods and SDK call patterns are all unchanged.

If your service sends script-based transfers, three numbers are worth checking. Set the gas budget, gas price times gas limit, to at least 0.05 KCAL, because an offer below the settled bill aborts the transfer, and unused gas comes back at settlement. Keep a SOUL float on the paying wallet for deposits on tokens sent to a fresh address, where 1 SOUL covers 500 new recipients and 10 SOUL covers 5,000. And if you send native transfers with an explicit data limit, raise it to 1,000,000, because the old default of 1,000 no longer covers even one fresh recipient row.

Mainnet Explorer | Activation block

Mainnet validators were updated on 20 and 27 August, the first releases since June. The two of them carry two months of work, and most of that work went into one question: if someone sets out to halt this chain, split it, corrupt its state or drain it, what do they reach first, and is it closed?

• The campaign started from a written threat model, re-proved every earlier audit conclusion against the source, and pinned each confirmed finding with a test so it cannot come back quietly.
• Hostile input now ends in a refused request while the node keeps producing blocks. Malformed transactions, numbers wider than the machine accepts, overlong strings and payloads, unreadable token schemas and series definitions, offers the sender cannot afford: every one of them is answered with a reason.
• Anything that declares a size is checked against the bytes actually present, and a read query arriving from the network has a ceiling on the work it may spend in the virtual machine. One costly question can no longer tie up a validator.
• The paths that parse untrusted bytes are fuzzed continuously. Raw transactions, all three entry points that accept native transaction envelopes, and the market's stored data are driven with mutated and truncated input, and every one of them has to end in a verdict.
• A place in the transaction queue has to be paid for. A validator confirms the paying account holds what it offers before the transaction takes its place, orders the queue by offer, and drops the lowest offer when the queue is full.
• A stuck leader is now replaced without anyone stepping in. The cases that used to leave the network waiting are handled: signatures for a leader change expire on their own, a vote that stalls falls back to an election, and a leader still completing its handshake counts as alive.
• Validators also got faster. The leader used to re-execute every block it had just built, checking its own work a second time, and that check is now optional, which hands the network back the capacity it was spending on it. Block compression level became configurable, connections between nodes no longer wait on Nagle's algorithm, and a cache warm-up that used to fire at random became an explicit setting.

Both releases are live across the mainnet validator set.

Mainnet Explorer | Network status