NewYour coding agent can read the release notes before it upgrades.Set up the MCP server →
pub.dev
pub.dev
The first native Flutter/Dart SDK for the Avalanche network. Pure Dart, no platform channels. Covers C-Chain EVM, Data API (Glacier), P-Chain staking, and X-Chain native assets.
Last release 24 days ago
29 Oct 2026
Ships on a steady schedule
a new release about every 3 weeks
Unknown
no stable releases
Nothing withdrawn
no release was ever pulled
4 months old
8 releases · first in 2026
Drag across the ruler to compare, or tap a release to open it.
Phase 3 started: indexed on-chain data without running a node.
Phase 3 started: indexed on-chain data without running a node.
final glacier = GlacierClient(network: NetworkConfig.fuji);
final avax = await glacier.getAvaxBalance('0xe9d70EE1...');
print('${avax.balanceInAvax} ${avax.symbol}');
final page = await glacier.getTransactions('0xe9d70EE1...', pageSize: 10);
Run live against Fuji Testnet; balances and history match Snowtrace.
368/368 passing
v0.2.2-dev: Glacier WebSocket (real-time events)
Phase 3 started: Glacier Data API REST client implemented and verified against Fuji Testnet. Indexed balances, transaction history and ERC-20 transfer history are now available without running a node.
GlacierClient: REST client for the Avalanche Glacier Data API
apiKey, sent as the x-glacier-api-key header. Without
a key the unauthenticated tier applies (6,000 CUs/min); with a free
key from the Builder Hub the limit is 8,000 CUs/mingetAvaxBalance(address): native balance (balances:getNative)getErc20Balances(address, {pageSize, pageToken}): ERC-20 balances
(balances:listErc20)getTransactions(address, {pageSize, pageToken}): native transaction
history (transactions:listNative)getErc20Transfers(address, {pageSize, pageToken}): ERC-20 transfer
history (transactions:listErc20)getTransaction(txHash): single transaction, returns the
nativeTransaction object (transactions/{txHash})AvalancheException on HTTP errors; the 429 message points
to the API key signup; non-JSON error bodies (for example a 502 from
a gateway) are handled without a FormatExceptionGlacierNativeBalance: balance, symbol, decimals,
balanceInAvaxGlacierErc20Balance: balance, symbol, decimals, optional
price and priceCurrency, balanceInTokensGlacierTransaction: txHash, from, to, value, gasUsed,
gasPrice, txStatus, isSuccess, valueInAvaxGlacierErc20Transfer: token transfer event with logIndex,
value, token address, symbol and decimals, valueInTokensGlacierPage<T>: items, nextPageToken, hasNextPage
(UUID page tokens, valid for 24 hours)NetworkConfig.chainId: chain ID as a string for Glacier paths
("43113" Fuji, "43114" Mainnet)example/phase3/glacier_read_example.dart: balances, history and
pagination against Fuji Testnetbuild.avax.network for balances:getNative,
balances:listErc20, transactions:listNative,
transactions:listErc20 and transactions/{txHash}nextPageTokengetTransaction returns only nativeTransaction. The erc20Transfers,
erc721Transfers, erc1155Transfers and internalTransactions that
the API sends for the same transaction are not modeled yetgetTransactions as a native
transaction with value 0; the token movement is in
getErc20TransfersgetErc20Balances uses the API default of filtering spam tokensPhase 3 in progress: Glacier REST client available. Not ready for production use. Next: Glacier WebSocket (real-time events) -> v0.2.2-dev
Your coding agent can read these notes before it upgrades. Set up the MCP server →
One column per month.
Phase 2 complete: AVAX and ERC-20 transfers verified on Fuji Testnet.
Phase 2 complete: AVAX and ERC-20 transfers verified on Fuji Testnet.
AVAX transfer (v0.1.2-dev): TX: 0x43f9d7b50013a5b18b0c1b6eda82875a39f7e7a01d114fa62595ced6f52d1ff2 0.001 AVAX | Block 58,211,707 ✅
ERC-20 USDC transfer (v0.2.0-dev): TX: 0x398ac7a99a3407d1b481d7c61ba5aee298b6cc6d500ecdcb614d12a7742aaa71 1 USDC | Block 59,193,138 ✅
final erc20 = ERC20Client(CChainClient(network: NetworkConfig.fuji));
final txHash = await erc20.transfer(
tokenAddress: ERC20Constants.usdcFuji,
toAddress: '0xRECEIVER',
amount: BigInt.from(1000000), // 1 USDC
privateKey: privateKey,
nonce: nonce,
chainId: 43113,
);
336/336 passing
v0.3.x: Glacier REST API (balances, transaction history)
Phase 2 complete: ERC-20 token transfers implemented, signed, and verified on Fuji Testnet.
ERC20Constants: ERC-20 function selectors and official token addresses
transfer (0xa9059cbb),
balanceOf (0x70a08231), approve (0x095ea7b3),
allowance (0xdd62ed3e), transferFrom (0x23b872dd),
decimals (0x313ce567), symbol (0x95d89b41)0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E0x5425890298aed601595a70AB815c96711a31Bc650x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7ERC20Client: ERC-20 token interactions for Avalanche C-Chain
eth_call:
balanceOf(tokenAddress, ownerAddress): balance in smallest unitdecimals(tokenAddress): token decimals (USDC = 6)symbol(tokenAddress): token symbol (e.g. "USDC")allowance(tokenAddress, ownerAddress, spenderAddress): allowancetransfer(tokenAddress, toAddress, amount, ...): token transferapprove(tokenAddress, spenderAddress, amount, ...): approve spendertransferFrom(tokenAddress, fromAddress, toAddress, amount, ...):
delegated transferaddress: 32 bytes left-padded with zerosuint256: big-endian 32 bytesstring: offset(32) + length(32) + UTF-8 dataCChainClient.ethCall(): public method for read-only contract callsAvaxTransferTransaction: added optional data field (Uint8List?)
for contract interactions. Fixes RLP encoding bug where duplicate
Uint8List(0) caused extra 0x80 byte before accessListtypedef ERC20Transaction = AvaxTransferTransactionscripts/pre_commit.sh: macOS/Linux equivalent of pre_commit.ps1First ERC-20 transfer from avalanche_flutter_sdk: TX Hash : 0x398ac7a99a3407d1b481d7c61ba5aee298b6cc6d500ecdcb614d12a7742aaa71 Block : 59,193,138 Status : Success ✅ Token : USDC (0x5425890298aed601595a70AB815c96711a31Bc65) Amount : 1 USDC Confirmed: ~2 seconds (Avalanche Snowman consensus) Explorer : https://testnet.snowtrace.io/tx/0x398ac7a99a3407d1b481d7c61ba5aee298b6cc6d500ecdcb614d12a7742aaa71
Phase 2 complete: AVAX and ERC-20 (USDC) transfers operational
on Fuji Testnet.
Not ready for production use.
Next: Glacier REST API (balances, transaction history) -> v0.3.x.
First on-chain write operation from avalanche_flutter_sdk.
First on-chain write operation from avalanche_flutter_sdk.
TX: 0x43f9d7b50013a5b18b0c1b6eda82875a39f7e7a01d114fa62595ced6f52d1ff2 Amount: 0.001 AVAX | Block: 58,211,707 | ~2s confirmation ✅
final tx = AvaxTransferTransaction(
chainId: 43113,
nonce: nonce,
maxPriorityFeePerGas: options.normal.maxPriorityFeePerGas,
maxFeePerGas: options.normal.maxFeePerGas,
gasLimit: BigInt.from(21000),
to: '0xRECEIVER',
value: BigInt.parse('1000000000000000'),
);
final txHash = await client.sendRawTransaction(tx.sign(privateKey));
323/323 passing
v0.2.0-dev: ERC-20 transfers (USDC/USDT) - Phase 2 complete
Phase 2 continued: EIP-1559 AVAX transfers implemented, signed, and verified on Fuji Testnet. First on-chain write operation from avalanche_flutter_sdk.
EcdsaSignature: secp256k1 signature model with r, s, v
v: recovery id (0 or 1) - EIP-1559 signatureYParity
(not legacy 27/28)PrivateKey.signDigest(Uint8List digest): signs a 32-byte digest
ECDSASigner)RlpEncoder: Recursive Length Prefix encoding from scratch
BigInt, int, Uint8List, and nested ListAvaxTransferTransaction: EIP-1559 AVAX transfer builder and signer
unsignedHash(): keccak256(0x02 || RLP([unsigned fields]))sign(PrivateKey): returns hex raw transaction starting with 0x02CChainClient.sendRawTransaction(rawTx): broadcasts signed transaction
(eth_sendRawTransaction) - returns transaction hashexample/phase2/generate_wallets_example.dart: generates sender
and receiver wallets for Fuji Testnet testingexample/phase2/avax_transfer_example.dart: end-to-end EIP-1559
AVAX transfer on Fuji TestnetFirst real transaction from avalanche_flutter_sdk:
TX Hash : 0x43f9d7b50013a5b18b0c1b6eda82875a39f7e7a01d114fa62595ced6f52d1ff2
Block : 58,211,707
Status : Success ✅
Amount : 0.001 AVAX
Gas used : 21,000 units (standard EVM transfer)
Confirmed: ~2 seconds (Avalanche Snowman consensus)
Explorer : https://testnet.snowtrace.io/tx/0x43f9d7b50013a5b18b0c1b6eda82875a39f7e7a01d114fa62595ced6f52d1ff2
SDK compatibility with Core Wallet confirmed: same mnemonic -> same address derivation ✅
Phase 2 in progress: AVAX transfers operational on Fuji Testnet.
Not ready for production use.
Next: ERC-20 transfers (USDC, USDT) -> v0.2.0-dev
Phase 2 started: C-Chain read operations available.
Phase 2 started: C-Chain read operations available.
final client = CChainClient(network: NetworkConfig.fuji);
final balance = await client.getBalance('0x71C7...');
final estimator = GasEstimator(client);
final options = await estimator.getPriceOptions();
print(options.normal.maxFeePerGas); // in Wei278/278 passing · 24 new tests
v0.1.2-dev: AvaxTransferTransaction (EIP-1559 signing + broadcast)
Phase 2 started: C-Chain JSON-RPC client and EIP-1559 gas estimation implemented and verified against official Avalanche documentation.
CChainClient: JSON-RPC client for the Avalanche C-Chain
getBalance(address): AVAX balance in Wei (eth_getBalance)getTransactionCount(address): nonce (eth_getTransactionCount)getBlockNumber(): latest accepted block (eth_blockNumber)getTransactionReceipt(txHash): receipt or nullgetBaseFee(): next block base fee in Wei (eth_baseFee,
Avalanche-specific)getMaxPriorityFeePerGas(): tip in Wei
(eth_maxPriorityFeePerGas)suggestPriceOptions(): slow/normal/fast gas options
(eth_suggestPriceOptions, Avalanche-specific)estimateGas({to, from, value, data}): gas units
(eth_estimateGas)AvalancheException on RPC and HTTP errorsGasEstimator: higher-level EIP-1559 gas estimation
getPriceOptions(): delegates to eth_suggestPriceOptionsgetBaseFee(): delegates to eth_baseFeegetOption(GasSpeed): returns single tier (slow/normal/fast)estimateTransferFee(speed): maxFeePerGas × 21,000 gas unitsavaxTransferGasLimit: 21,000 (standard EVM transfer cost)GasPriceOption: EIP-1559 fee model for a single speed tier
maxPriorityFeePerGas and maxFeePerGas in WeieffectiveFee(baseFee):
min(maxFeePerGas, baseFee + maxPriorityFeePerGas)maxPriorityFeePerGasInNAvax and maxFeePerGasInNAvax helpersGasPriceOptions: container for slow, normal, and fast tiersGasSpeed enum: slow, normal, fasteth_suggestPriceOptions response format verified against
official example from
build.avax.network/docs/rpcs/c-chain#eth_suggestpriceoptionsmin(gasFeeCap, baseFee + gasTipCap) per
build.avax.network/docs/rpcs/other/guides/txn-feesPhase 2 in progress: C-Chain read operations available.
Not ready for production use.
Next: AvaxTransferTransaction (EIP-1559 signing and broadcast)
-> v0.1.2-dev
Phase 1 complete: the first native Flutter/Dart SDK for Avalanche can now derive wallets and addresses for all three chains.
Phase 1 complete: the first native Flutter/Dart SDK for Avalanche
can now derive wallets and addresses for all three chains.
final mnemonic = Mnemonic.generate(wordlist: WordlistEs.instance);
final wallet = HDWallet.fromMnemonic(mnemonic);
final cAddr = EvmAddress.fromPublicKey(
wallet.derivePublicKeyForCChain());
final xpAddr = XPAddress.fromPublicKey(
wallet.derivePublicKeyForXPChain());254/254 passing · 46 new tests this release
M2: C-Chain JSON-RPC client (EIP-1559 AVAX transfers, ERC-20)
Phase 1 complete: full wallet cycle implemented and verified. Given a mnemonic, the SDK can now derive addresses for all three Avalanche chains (C-Chain, X-Chain, P-Chain).
Seed: BIP-39 seed derivation via PBKDF2-HMAC-SHA512
Seed.fromMnemonic(): derives 512-bit seed from a Mnemonic
instance with optional passphraseSeed.fromPhrase(): derives from raw phrase stringtoString() returns Seed[REDACTED]HDWallet: BIP-32/BIP-44 hierarchical deterministic wallet
HDWallet.fromSeed(): derives master key via
HMAC-SHA512(key="Bitcoin seed", data=seed)HDWallet.fromMnemonic(): convenience constructorderivePrivateKeyForCChain(index): path m/44'/60'/0'/0/n
(coin_type=60, EVM-compatible, Core Wallet + MetaMask)derivePrivateKeyForXPChain(index): path m/44'/9000'/0'/0/n
(coin_type=9000, Avalanche native)derivePublicKeyForCChain(index) and
derivePublicKeyForXPChain(index) convenience methodstoString() returns HDWallet[REDACTED]EvmAddress: C-Chain EVM address derivation
EvmAddress.fromPublicKey(): keccak256(toRawUncompressed())
→ last 20 byteschecksumAddress: EIP-55 mixed-case checksum with 0x prefixlowercaseAddress: lowercase hex with 0x prefixEvmAddress.fromHex(): import from hex stringXPAddress: X-Chain and P-Chain Bech32 address derivation
XPAddress.fromPublicKey(): SHA256(compressed) → RIPEMD160
→ 20 bytes → Bech32xChainAddress(network): X-avax1{bech32} (mainnet) or
X-fuji1{bech32} (testnet)pChainAddress(network): P-avax1{bech32} (mainnet) or
P-fuji1{bech32} (testnet)AvalancheNetwork enum: mainnet (hrp=avax),
fuji (hrp=fuji)abandon x11 + about → c55257...3b04legal winner...yellow → 2e8905...f607letter advice...above → d71de8...52a8support.core.app/en/articles/7004986eips.ethereum.org/EIPS/eip-55):
0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d3590xdbF03B407c01E7cD3CBea99509d93f8DDDC8C6FB0xD1220A0cf47c7B9Be7A2E6BA89F429762e7b9aDbdocs.avax.network/docs/rpcs/other/standards/cryptographic-primitivesPhase 1 complete: full wallet cycle operational.
Not ready for production use.
Next: Phase 2 -> C-Chain JSON-RPC client (EIP-1559 transfers, ERC-20).
BIP-39 mnemonics EN + ES complete and verified.
BIP-39 mnemonics EN + ES complete and verified.
Ready to publish v0.0.3-dev to pub.dev.
Next: HD key derivation (BIP-44) + address derivation (develop)
Phase 1 in progress: BIP-39 mnemonic generation implemented and verified in English and Spanish.
MnemonicStrength: enum with 5 valid BIP-39 entropy strengths
words12 (128 bits), words15 (160 bits), words18 (192 bits),
words21 (224 bits), words24 (256 bits)bits, bytes, checksumBits, totalBits, wordCount
per BIP-39 formula: CS = ENT / 32, MS = (ENT + CS) / 11Entropy: BIP-39 entropy generation and checksum computation
generate(): cryptographically secure random bytes using
FortunaRandom + Random.secure() (consistent with PrivateKey)validate(): throws ArgumentError for invalid entropy sizescomputeChecksum(): first ENT/32 bits of SHA256(entropy)toBits(): entropy + checksum as bit list for word index computationWordlist: abstract base class for BIP-39 wordlists
wordAt(index): returns word at index 0-2047indexOf(word): binary search O(log n) - valid per BIP-39 sorted speccontains(word): delegates to indexOfvalidate(): checks length == 2048 and words are sortedWordlistEn: official BIP-39 English wordlist (2048 words)
WordlistEn.instancegithub.com/bitcoin/bips/blob/master/bip-0039/english.txtabandon (index 0), last word: zoo (index 2047)WordlistEs: official BIP-39 Spanish wordlist (2048 words)
WordlistEs.instancegithub.com/bitcoin/bips/blob/master/bip-0039/spanish.txtwordAt() returns NFC for callersindexOf('abaco') == indexOf('ábaco')indexOf('Domingo') == indexOf('domingo')Mnemonic: BIP-39 mnemonic generation, import, and validation
Mnemonic.generate(): generates from cryptographically secure entropy;
default 12 words English, configurable strength and wordlistMnemonic.fromEntropy(): deterministic generation from entropy bytesMnemonic.fromPhrase(): imports and validates existing phrase;
verifies BIP-39 checksum; accepts extra whitespace between wordstoEntropy(): reconstructs original entropy from word indicestoString() returns Mnemonic[REDACTED] - phrase is equivalent
in sensitivity to a private key; use phrase getter explicitlyabandon abandon ... about (12 words) ✅legal winner ... yellow (12 words) ✅letter advice ... above (12 words) ✅zoo zoo ... wrong (12 words) ✅abandon abandon ... art (24 words) ✅WordlistEn binary search: wordAt/indexOf round-trip consistent
at indices 0, 1024, and 2047Phase 1 in progress: BIP-39 mnemonics (EN + ES) complete and tested.
Not ready for production use.
Next: HD key derivation (BIP-44) + EVM and X/P-Chain address derivation.
secp256k1 PrivateKey/PublicKey + CB58 encoding complete and verified.
secp256k1 PrivateKey/PublicKey + CB58 encoding complete and verified.
Ready to publish v0.0.2-dev to pub.dev. Next: BIP-39 mnemonics (EN + ES) + HD key derivation (develop)
Phase 1 in progress: secp256k1 cryptography implemented and verified.
PrivateKey: secp256k1 private key generation, import, and export
PrivateKey.generate() using FortunaRandom (cryptographically
secure pseudo-random number generator)PrivateKey.fromHex() with strict range validation against the
curve order n (rejects d <= 0 and d >= n)toHex(), toBytes(): 32-byte big-endian exportpublicKey getter: derives Q = d * G per secp256k1toString() returns PrivateKey[REDACTED] - key material is
never exposed via logs, error messages, or debug outputPublicKey: secp256k1 public key derivation, import, and encoding
PublicKey.fromEcPoint(), PublicKey.fromHex() (accepts both
compressed and uncompressed SEC1 encodings)toCompressed(): 33-byte SEC1 encoding - required input for
X-Chain/P-Chain address derivation (sha256 + ripemd160)toUncompressed() / toRawUncompressed(): 65-byte and 64-byte
encodings - required input for C-Chain/EVM address derivation
(keccak256)==, hashCode) based on the underlying
elliptic curve pointpointycastle: ^4.0.0 and meta: ^1.15.0 added as dependenciesn confirmed directly from pointycastle's
ECDomainParameters('secp256k1') at runtime:
fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141d=0 (rejected), d=1 (accepted), d=n-1 (accepted), d=n
(rejected), d=n+1 (rejected)Phase 1 in progress: secp256k1 PrivateKey/PublicKey complete and
tested.
Not ready for production use.
Next: CB58 encoding, then EVM and X/P-Chain address derivation.
SECURITY.md: vulnerability reporting and key handling policy
Initial SDK scaffold - Phase 1 in progress.
SDK Core
Quality Infrastructure
Documentation
After merging and publishing v0.0.1-dev on pub.dev:
Phase 1 (M1): secp256k1 key generation, BIP-39 mnemonics (EN + ES),
HD key derivation (BIP-44), EVM address derivation from public key
Phase 1 in progress: SDK skeleton and project architecture.
AvalancheClient: main entry point for the SDK
NetworkConfig for Mainnet or Fuji TestnetNetworkConfig: official Avalanche RPC endpoint configurations
NetworkConfig.mainnet: Avalanche Mainnet (C-Chain, P-Chain, X-Chain, Glacier API)NetworkConfig.fuji: Avalanche Fuji Testnet (C-Chain, P-Chain, X-Chain, Glacier API)docs.avax.networkNetworkId: enum for Mainnet (1) and Fuji Testnet (5)AvalancheException: base exception class for all SDK errorsanalysis_options.yaml with very_good_analysis linter (zero warnings enforced)scripts/pre_commit.ps1: local quality gate (format + analyze + test).github/workflows/ci.yml: GitHub Actions CI pipeline
develop push).github/pull_request_template.md: PR checklistCONTRIBUTING.md: branch strategy, commit conventions, code and testing standardsSECURITY.md: vulnerability reporting policy and key handling rulesPhase 1 in progress: SDK skeleton, project architecture, and CI infrastructure complete.
Not ready for production use.
Next: secp256k1 key generation, BIP-39 mnemonics (EN + ES), HD key derivation (BIP-44).