Docs Reference
Bridge program
The acrux_bridge program on Solana mainnet and on Acrux. The vault and deposit records, the light client of Acrux, withdrawals and their release, native ACRUX from slot 4,752,000, every account, instruction and error.
acrux_bridge moves SPL tokens between Solana and Acrux. On Solana it locks deposits in a vault per mint and keeps a light client of Acrux: the validator set of each Acrux epoch and the cblocks certified by it. On Acrux the same program burns withdrawals, and a cblock that Solana's light client certifies proves them to the vault. How to send a deposit or a withdrawal is on Move tokens across.
| Program | acrux_bridge |
| Program id | EDm6HxGArNEgGfWRZwvj42f4euc9oPQWVUwUbkK3PEe5 |
| Version | 0.1.0 |
The same program, at the same id, runs on both chains:
| Chain | What runs there |
|---|---|
| Solana mainnet | initialize and allow_mint, once, by the program's upgrade authority; deposit; the light client: init_validator_set, post_cblock, attest_cblock, hand_off; release; the closes |
| Acrux | withdraw, and from slot 4,752,000 withdraw_native. The program is placed at its address from slot 2,711,660, the bridge rule's first slot, and replaced at slot 4,752,000 by the build that adds withdraw_native (Programs on Acrux) |
ACRUX is the one mint allowed on Solana mainnet (ACRUX). The IDL is ACRUX_BRIDGE_IDL in @acrux/contract 0.1.21, built with Anchor 0.31.1. The API reads both chains.
Deposits and credits
deposit moves tokens from the depositor's token account into the mint's vault, a token account at ["vault", mint] that is its own authority, and writes a DepositRecord at ["deposit", sequence]. The record holds what the vault received, after any Token-2022 transfer fee. Sequences count up from 0, one per deposit.
Each Acrux validator reads the records through two independent Solana RPCs at finalized commitment, every two seconds, and keeps a record only when both return the same bytes. From the bridge rule's first slot a proposer block carries up to 16 credits in sequence beside its transactions, and every validator checks each one against the record it read itself: a block whose credit matches no finalized record is invalid (Validator). Before a slot's transactions execute, its credits are applied in sequence:
| Account on Acrux | Address under the program | Holds |
|---|---|---|
| Bridged mint | PDA ["mint", solana_mint] | an SPL Token mint with the Solana mint's decimals; mint authority PDA ["authority"], no freeze authority. For ACRUX, CoN68LBvgfADtuKXXZMq3PwJsTkAfb2yGmVUyfrn8yPE |
| Recipient's token account | the associated token account of the recipient for the bridged mint | the credited amount; created by the credit when the address holds nothing |
| Credit counter | PDA ["credited"] | the next sequence to credit, 8 bytes |
| Skipped credit | PDA ["skipped_credit", sequence] | a credit whose bridged mint or recipient account is not the plain token account the credit writes, kept with its reason; the counter moves on past it |
Withdrawals
withdraw on Acrux burns the bridged token from the owner's token account and writes a Withdrawal at ["withdrawal", sequence], counted in Outbound. The amount must reach the mint's least withdrawal, an 8-byte amount after an 8-byte discriminator at ["minimum", solana_mint], which the bridge rule writes at its first slot and no instruction changes. For ACRUX it is 1,000,000 base units, 1 ACRUX. A mint without one has no minimum.
Each cblock's outbox lists, as OutboxEntry values, the next epoch's validator set and every withdrawal burned in its four slots. Its Merkle root is part of the cblock hash the validators vote on. release on Solana takes a withdrawal entry and its Merkle proof against a certified Cblock, and pays from the vault into the recipient's token account for the Solana mint. The bit sequence mod 8192 in Released at ["released", sequence / 8192] is set after the payout, so each sequence is paid once. Any payer can send release; the proofs come from getCblockProof.
Native ACRUX
From Acrux slot 4,752,000, the bridge rule's nativeFromSlot, ACRUX bridged from Solana is Acrux's native balance, the one that pays every fee (Fees and the reserve rule). In that slot, before its transactions, every validator and follower:
- credits each bridged ACRUX balance to its holder's wallet as native lamports, 1,000 per base unit, and sets the bridged mint's supply to 0;
- retires the lamports every wallet held before, a wallet being a system account with no data: the faucet's grants, the genesis faucet, the validators' identities and the built-in traffic's senders;
- keeps the lamports of every data, token and program account, and records their total, with the rent of the two accounts below, once as the fixed reserve; at slot 5,184,000 the rent of the genesis vote accounts and the stake schedule's account joins it (Stake on Acrux), and from slot 5,616,000 the rent of each outside identity's vote account (Admission);
- places the build of
acrux_bridgethat addswithdraw_native, and writes the native gate.
From then on a deposit's credit adds its amount times 1,000 in lamports to the recipient's wallet; a recipient that is not a wallet is recorded as a skipped credit. withdraw_native takes lamports from the owner's wallet, at most what has been credited from Solana and not yet withdrawn, and writes the same Withdrawal record as withdraw, so the outbox, the light client and release on Solana are unchanged. The built-in traffic stops.
| Account on Acrux | Address under the program | Holds |
|---|---|---|
| Native gate | PDA ["native"] | NativeGate, written by the executor at the cut-over; no instruction creates it, and withdraw_native changes only withdrawn |
| Native burn | PDA ["native_burn"] | an empty account at its rent; withdraw_native moves the lamports here, and the executor removes them at the end of the slot |
getSupply answers nonCirculating, the reserve, and circulating, every lamport above it: what was credited from Solana, less what was withdrawn and the base fees burned. getNativeSupply and native on GET /v1/bridge give the gate's counters.
The light client
The light client knows Acrux's validators and their stakes for each bridge epoch of 432,000 Acrux slots, 108,000 cblocks. Its first set, epoch 6 with Acrux Net's twelve validators, was seeded once by init_validator_set. Every later set comes from Acrux: each cblock's outbox carries the next epoch's set, and hand_off proves it against a certified cblock of the epoch before. From epoch 14 that is the set frozen at the cut-off of the epoch before, outside validators included (Admission).
A cblock is posted once by post_cblock with its hash preimage and outbox root. The program hashes them together and requires the cblock's hash, so the root is the one the validators signed. attest_cblock then counts the votes that Solana's Ed25519 program verified in the same transaction. Each must be a validator of the cblock's epoch voting Notar or Finalize on its consensus slot and hash, over the message:
SHA-256(chainId) ‖ bincode Vote { validator, slot, Some(hash), kind }chainId is "acrux" on Acrux Net. The votes fill more than one transaction's 1,232 bytes, so a cblock is attested over several. It is certified once Finalize votes hold 60% of the epoch's stake, or Notar votes 80%, the thresholds of Consensus on cblocks.
Accounts
| Account | Address | Chain |
|---|---|---|
| Bridge | PDA ["bridge"] | Solana |
| AllowedMint | PDA ["allowed", mint] | Solana |
| Vault | PDA ["vault", mint], a token account | Solana |
| DepositRecord | PDA ["deposit", sequence] | Solana |
| ValidatorSet | PDA ["set", epoch] | Solana |
| Cblock | PDA ["cblock", hash] | Solana |
| Released | PDA ["released", sequence / 8192] | Solana |
| Outbound | PDA ["outbound"] | Acrux |
| Withdrawal | PDA ["withdrawal", sequence] | Acrux |
| Least withdrawal | PDA ["minimum", solana_mint] | Acrux |
| NativeGate | PDA ["native"] | Acrux, from slot 4,752,000 |
| Native burn | PDA ["native_burn"] | Acrux, from slot 4,752,000 |
Sequences and epochs in seeds are u64 little-endian.
Bridge
The deposit count and the light client's fixed values.
Discriminator: e7 e8 1f 62 6e 03 17 3b, then the fields in order, Borsh-encoded.
| Field | Type | Meaning |
|---|---|---|
deposits | u64 | deposits made so far; the next deposit's sequence number |
bump | u8 | the PDA bump |
authority | pubkey | the upgrade authority that initialized it; admits mints and seeds the first set |
epoch_slots | u64 | a bridge epoch's length in Acrux slots |
first_epoch | u64 | the only epoch the authority can seed directly |
seeded | bool | whether init_validator_set has run |
chain_id | [u8; 32] | prefix of every validator's signed vote, unique to this Acrux chain |
AllowedMint
Discriminator: ad e5 b3 2e 79 a4 f7 06, then the fields in order, Borsh-encoded.
| Field | Type | Meaning |
|---|---|---|
mint | pubkey | the admitted mint |
DepositRecord
Discriminator: 53 e8 0a 1f fb 31 bd a7, then the fields in order, Borsh-encoded.
| Field | Type | Meaning |
|---|---|---|
sequence | u64 | the deposit's sequence, from 0 |
depositor | pubkey | the Solana wallet that signed the deposit |
recipient | pubkey | the Acrux address the deposit is credited to |
mint | pubkey | the Solana mint |
amount | u64 | what the vault received, in the mint's base units |
slot | u64 | the Solana slot the deposit landed in |
bump | u8 | the PDA bump |
ValidatorSet
Discriminator: 23 ce 61 ca 2b 0b 0b 7f, then the fields in order, Borsh-encoded.
| Field | Type | Meaning |
|---|---|---|
epoch | u64 | the bridge epoch, slot / 432,000 in Acrux slots |
total | u64 | the sum of the validators' stakes |
validators | Validator[] | Acrux's validators in their validator order, each with its stake |
payer | pubkey | receives the rent when this account is closed |
Validator
| Field | Type | Meaning |
|---|---|---|
key | pubkey | the validator's identity |
stake | u64 | its stake in lamports |
Cblock
Discriminator: 6f b6 c8 21 91 60 1a 1e, then the fields in order, Borsh-encoded.
| Field | Type | Meaning |
|---|---|---|
slot | u64 | the cblock's consensus slot |
epoch | u64 | its bridge epoch, slot × 4 / epoch_slots |
hash | [u8; 32] | the cblock hash the validators vote on |
outbox_root | [u8; 32] | the Merkle root of its outbox |
notar | u32 | the validators whose Notar vote was verified, one bit each by index in the set |
finalize | u32 | the validators whose Finalize vote was verified, one bit each by index in the set |
certified | bool | Finalize votes hold 60% of the stake, or Notar votes 80% |
payer | pubkey | receives the rent when this account is closed |
Released
Discriminator: c8 77 7a 05 4b 77 8d f1, then the fields in order, Borsh-encoded.
| Field | Type | Meaning |
|---|---|---|
bucket | u64 | sequence / 8192 of the withdrawals it guards |
bits | [u8; 1024] | low bit first within each byte; a bit is set only after the payout succeeds |
Outbound
Discriminator: 25 f2 0b 6b f2 9c 46 81, then the fields in order, Borsh-encoded.
| Field | Type | Meaning |
|---|---|---|
withdrawals | u64 | withdrawals made so far; the next withdrawal's sequence |
bump | u8 | the PDA bump |
Withdrawal
Discriminator: 0a 2d d3 b6 81 eb 5a 52, then the fields in order, Borsh-encoded.
| Field | Type | Meaning |
|---|---|---|
sequence | u64 | the withdrawal's sequence, from 0 |
owner | pubkey | the Acrux address that burned it |
recipient | pubkey | the Solana address paid out of the vault |
solana_mint | pubkey | the Solana mint the vault pays |
amount | u64 | base units burned and paid |
slot | u64 | the Acrux slot of the burn; its cblock's outbox carries the withdrawal |
bump | u8 | the PDA bump |
NativeGate
Discriminator: 63 cc b2 cb 54 6b 26 41, then the fields in order, Borsh-encoded.
| Field | Type | Meaning |
|---|---|---|
solana_mint | pubkey | the Solana mint whose deposits are credited as lamports |
lamports_per_base_unit | u64 | lamports per base unit, 1,000 for ACRUX |
credited | u64 | lamports credited from Solana, the balances converted at the cut-over included |
withdrawn | u64 | lamports withdrawn; never more than credited |
reserve | u64 | the fixed reserve, lamports |
slot | u64 | the cut-over slot |
ProofNode
One step of a Merkle proof: the running hash starts as SHA-256 of the entry's bincode bytes, and each step hashes it with hash on the side left names.
| Field | Type | Meaning |
|---|---|---|
left | bool | whether the sibling sits left of the running hash |
hash | [u8; 32] | the sibling hash |
Instructions
deposit emits its event by self CPI, so its accounts end with event_authority and program.
| Instruction | Chain | Signers | Does |
|---|---|---|---|
initialize | Solana | the program's upgrade authority | creates the Bridge with the epoch length, the first epoch and the chain tag |
allow_mint | Solana | the bridge authority | admits a mint |
deposit | Solana | depositor | locks tokens in the vault and records the deposit |
init_validator_set | Solana | the bridge authority | seeds the first epoch's validator set, once |
post_cblock | Solana | payer | posts a cblock to certify |
attest_cblock | Solana | none | counts the votes verified in the same transaction |
hand_off | Solana | payer | creates the next epoch's validator set from a certified cblock |
release | Solana | payer | pays a proven withdrawal from the vault |
close_cblock | Solana | the cblock's payer | returns a posted cblock's rent |
close_validator_set | Solana | the set's payer | returns an old set's rent, keeping the newest two |
withdraw | Acrux | owner | burns a bridged token and records the withdrawal |
withdraw_native | Acrux, from slot 4,752,000 | owner | takes native ACRUX and records the withdrawal |
initialize
Only the upgrade authority recorded in the program's ProgramData can call it. epoch_slots is a positive multiple of 4; chain_id is the 32-byte chain tag, SHA-256 of the chain's name, and not all zeros.
Discriminator: af af 6d 1f 0d 98 9b ed.
| Arg | Type | Meaning |
|---|---|---|
epoch_slots | u64 | a bridge epoch's length in Acrux slots, 432,000 |
first_epoch | u64 | the epoch init_validator_set seeds |
chain_id | [u8; 32] | SHA-256 of the chain's name, the prefix of every signed vote |
| # | Account | Writable | Signer | Address | Meaning |
|---|---|---|---|---|---|
| 0 | payer | yes | yes | the program's upgrade authority; becomes the bridge authority and pays the rent | |
| 1 | bridge | yes | PDA ["bridge"] | created | |
| 2 | program | EDm6HxGArNEgGfWRZwvj42f4euc9oPQWVUwUbkK3PEe5 | this program | ||
| 3 | program_data | this program's ProgramData, whose upgrade authority must be payer | |||
| 4 | system_program | System program |
allow_mint
Discriminator: f0 1c f0 46 7c f0 f5 e1.
Args: none.
| # | Account | Writable | Signer | Address | Meaning |
|---|---|---|---|---|---|
| 0 | authority | yes | yes | the bridge authority; pays the rent | |
| 1 | bridge | PDA ["bridge"] | |||
| 2 | mint | the mint to admit, SPL Token or Token-2022 | |||
| 3 | allowed | yes | PDA ["allowed", mint] | created | |
| 4 | system_program | System program |
deposit
amount is in the mint's base units and more than 0, and the vault must receive more than 0. The vault is created by the mint's first deposit. The depositor pays the record's rent.
Discriminator: f2 23 c6 89 52 e1 f2 b6.
| Arg | Type | Meaning |
|---|---|---|
amount | u64 | base units to move from source |
recipient | pubkey | the Acrux address credited |
| # | Account | Writable | Signer | Address | Meaning |
|---|---|---|---|---|---|
| 0 | depositor | yes | yes | owns source; pays the rent | |
| 1 | bridge | yes | PDA ["bridge"] | its deposits count names the record | |
| 2 | mint | an admitted mint | |||
| 3 | allowed | PDA ["allowed", mint] | the mint's admission | ||
| 4 | source | yes | the depositor's token account for the mint | ||
| 5 | vault | yes | PDA ["vault", mint] | the mint's vault: a token account at ["vault", mint] that is its own authority, created by the mint's first deposit | |
| 6 | record | yes | PDA ["deposit", bridge.deposits] | created at the next sequence | |
| 7 | token_program | SPL Token or Token-2022, the mint's owner | |||
| 8 | system_program | System program | |||
| 9 | event_authority | PDA ["__event_authority"] | self-CPI event signer | ||
| 10 | program | this program |
init_validator_set
Accepted once, for the Bridge's first_epoch, with 1 to 32 validators in Acrux's validator order.
Discriminator: 77 b4 99 36 0d d5 44 69.
| Arg | Type | Meaning |
|---|---|---|
epoch | u64 | the Bridge's first_epoch |
validators | Validator[] | 1 to 32 validators with their stakes |
| # | Account | Writable | Signer | Address | Meaning |
|---|---|---|---|---|---|
| 0 | authority | yes | yes | the bridge authority; pays the rent | |
| 1 | bridge | yes | PDA ["bridge"] | ||
| 2 | set | yes | PDA ["set", epoch] | created | |
| 3 | system_program | System program |
post_cblock
The cblock's consensus slot is read from the first 8 bytes of the preimage, and its epoch is slot × 4 / epoch_slots.
Discriminator: 40 44 38 a4 0d a0 1a fe.
| Arg | Type | Meaning |
|---|---|---|
hash | [u8; 32] | the cblock hash |
outbox_root | [u8; 32] | its outbox's Merkle root |
preimage | bytes | the bytes that, followed by the root, hash to hash; its first 8 are the consensus slot |
| # | Account | Writable | Signer | Address | Meaning |
|---|---|---|---|---|---|
| 0 | payer | yes | yes | pays the rent and alone can close it | |
| 1 | bridge | PDA ["bridge"] | |||
| 2 | cblock | yes | PDA ["cblock", hash] | created | |
| 3 | system_program | System program |
attest_cblock
Every Ed25519 program instruction before this one in the transaction is read. Its signatures, public keys and messages must sit in its own data. Each verified signature sets the voter's bit in notar or finalize, by its index in the set.
Discriminator: f9 1f 29 a2 9e 77 49 af.
Args: none.
| # | Account | Writable | Signer | Address | Meaning |
|---|---|---|---|---|---|
| 0 | bridge | PDA ["bridge"] | its chain_id prefixes the votes | ||
| 1 | cblock | yes | PDA ["cblock", cblock.hash] | the posted cblock | |
| 2 | set | PDA ["set", cblock.epoch] | the validator set of the cblock's epoch | ||
| 3 | instructions | Sysvar1nstructions1111111111111111111111111 | the instructions sysvar |
hand_off
The cblock is certified and in epoch epoch − 1. The entry proven is OutboxEntry::ValidatorSet for epoch with the validators in order.
Discriminator: 11 e4 d2 9c 1a dc 9e 65.
| Arg | Type | Meaning |
|---|---|---|
epoch | u64 | the epoch handed on to, one after the cblock's |
validators | Validator[] | its validators with their stakes, as the outbox entry lists them |
proof | ProofNode[] | the entry's Merkle proof against the cblock's outbox root |
| # | Account | Writable | Signer | Address | Meaning |
|---|---|---|---|---|---|
| 0 | payer | yes | yes | pays the rent | |
| 1 | cblock | PDA ["cblock", cblock.hash] | a certified cblock of the epoch before | ||
| 2 | next | yes | PDA ["set", epoch] | created | |
| 3 | system_program | System program |
release
The entry proven is OutboxEntry::Withdrawal with sequence, the mint, recipient and amount. destination is a token account of the mint owned by recipient.
Discriminator: fd f9 0f ce 1c 7f c1 f1.
| Arg | Type | Meaning |
|---|---|---|
sequence | u64 | the withdrawal's sequence |
recipient | pubkey | the Solana address paid |
amount | u64 | base units paid |
proof | ProofNode[] | the withdrawal entry's Merkle proof against the cblock's outbox root |
| # | Account | Writable | Signer | Address | Meaning |
|---|---|---|---|---|---|
| 0 | payer | yes | yes | sends the release; pays the bucket's rent the first time | |
| 1 | cblock | PDA ["cblock", cblock.hash] | the certified cblock whose outbox holds the withdrawal | ||
| 2 | mint | the Solana mint | |||
| 3 | vault | yes | PDA ["vault", mint] | the mint's vault, which pays | |
| 4 | destination | yes | recipient's token account for the mint | ||
| 5 | released | yes | created by the bucket's first release | ||
| 6 | token_program | SPL Token or Token-2022, the mint's owner | |||
| 7 | system_program | System program |
close_cblock
Discriminator: b8 46 93 a2 30 f7 f9 4f.
Args: none.
| # | Account | Writable | Signer | Address | Meaning |
|---|---|---|---|---|---|
| 0 | payer | yes | yes | the cblock's payer; receives the rent | |
| 1 | cblock | yes | PDA ["cblock", cblock.hash] | closed |
close_validator_set
newest is at least two epochs after set.
Discriminator: 31 bd da 9d 06 4a fb cf.
Args: none.
| # | Account | Writable | Signer | Address | Meaning |
|---|---|---|---|---|---|
| 0 | payer | yes | yes | the set's payer; receives the rent | |
| 1 | set | yes | PDA ["set", set.epoch] | closed | |
| 2 | newest | PDA ["set", newest.epoch] | a set at least two epochs later |
withdraw
amount is more than 0 and at least the mint's least withdrawal. The owner pays the record's rent, and the first withdrawal's for Outbound.
Discriminator: b7 12 46 9c 94 6d a1 22.
| Arg | Type | Meaning |
|---|---|---|
solana_mint | pubkey | the Solana mint the bridged token stands for |
amount | u64 | base units to burn, at least the mint's least withdrawal |
recipient | pubkey | the Solana address paid |
| # | Account | Writable | Signer | Address | Meaning |
|---|---|---|---|---|---|
| 0 | owner | yes | yes | owns source; pays the rent | |
| 1 | mint | yes | PDA ["mint", solana_mint] | the bridged mint | |
| 2 | minimum | PDA ["minimum", solana_mint] | the mint's least withdrawal; an empty address for none | ||
| 3 | source | yes | the owner's token account for the bridged mint | ||
| 4 | outbound | yes | PDA ["outbound"] | created by the first withdrawal | |
| 5 | record | yes | PDA ["withdrawal", outbound.withdrawals] | created at the next sequence | |
| 6 | token_program | SPL Token | |||
| 7 | system_program | System program |
withdraw_native
amount is in the Solana mint's base units, more than 0 and at least its least withdrawal; the owner's wallet pays it times the gate's scale in lamports, beside the fee and the rent. A withdrawal past what has been credited from Solana and not yet withdrawn is refused with UnbackedNativeWithdrawal. The owner pays the record's rent, and the first withdrawal's for Outbound.
Discriminator: 71 e3 1a 20 35 42 5a fa.
| Arg | Type | Meaning |
|---|---|---|
amount | u64 | base units of the Solana mint, at least its least withdrawal |
recipient | pubkey | the Solana address paid |
| # | Account | Writable | Signer | Address | Meaning |
|---|---|---|---|---|---|
| 0 | owner | yes | yes | pays amount times the gate's scale in lamports, and the rent | |
| 1 | native | yes | PDA ["native"] | the native gate | |
| 2 | minimum | PDA ["minimum", native.solana_mint] | the mint's least withdrawal | ||
| 3 | burn | yes | PDA ["native_burn"] | takes the lamports; the executor removes them at the end of the slot | |
| 4 | outbound | yes | PDA ["outbound"] | created by the first withdrawal | |
| 5 | record | yes | PDA ["withdrawal", outbound.withdrawals] | created at the next sequence | |
| 6 | system_program | System program |
Events
| Event | Fields | Emitted by |
|---|---|---|
Deposited | sequence: u64; depositor: pubkey; recipient: pubkey; mint: pubkey; amount: u64; slot: u64 | deposit |
Errors
Anchor custom errors, returned as custom program error: 0x… with the code below.
| Code | Name | Message |
|---|---|---|
| 6000 | ZeroAmount | A deposit moves more than nothing. |
| 6001 | BadEpoch | An epoch is a positive number of cblocks. |
| 6002 | BadSet | A validator set holds 1 to 32 validators. |
| 6003 | BadPreimage | The preimage and outbox root do not hash to the cblock's hash. |
| 6004 | BadVote | A signature is not a validator's Notar or Finalize vote on this cblock. |
| 6005 | NotCertified | The cblock is not certified in the epoch before the set it hands on. |
| 6006 | BadProof | The validator set is not in the cblock's outbox. |
| 6007 | RecentValidatorSet | The newest two validator sets stay open. |
| 6008 | NotUpgradeAuthority | Only the program's upgrade authority can initialize the bridge. |
| 6009 | AlreadySeeded | The first validator epoch can be seeded only once. |
| 6010 | BadChainId | The chain tag must be set. |
| 6011 | AlreadyReleased | This withdrawal has already been released. |
| 6012 | InvalidMinimum | The withdrawal minimum account is invalid. |
| 6013 | BelowMinimumWithdrawal | The withdrawal amount is below this mint's configured minimum. |
| 6014 | InvalidNativeGate | The native bridge gate or burn account is invalid. |
| 6015 | NativeAmountOverflow | The native withdrawal amount overflows its configured scale or counter. |
| 6016 | UnbackedNativeWithdrawal | The native withdrawal exceeds the tokens credited from Solana. |
| 6017 | AlreadyBurned | This fee-burn epoch has already been burned. |
| 6018 | BadFeeBurnEpoch | A fee burn belongs to the last cblock of its epoch. |
| 6019 | WrongFeeBurnMint | Fee burns use the immutable configured native mint. |