Ξ.100
WHAT DOES A 10% SELL ACTUALLY DO?
Bad answer:
IT COSTS 10%.
True.
Useless.
Try again.
Define transaction classes:
E ∈ {BUY, SELL, TRANSFER}
Each event:
E(a,b,x,n)
where:
a := sender
b := receiver
x := gross SOLUM amount
n := block
Now define fee vector:
φ(E) := [B,R,L,T]
where:
B := Burn
R := Reflection
L := Liquidity
T := Treasury
Not:
B := byte
Not:
R := canonical rules
Not:
T := Territory
Symbol collision detected.
Disambiguate locally:
Bᶠ := Burn component
Rᶠ := Reflection component
Lᶠ := Liquidity component
Tᶠ := Treasury component
Then:
φ(E) := [Bᶠ,Rᶠ,Lᶠ,Tᶠ]
INITIAL::
φ(BUY) = [0,0,0.5,0.5]
φ(SELL) = [4,3,2,1]
φ(TRANSFER) = [2,3,0,0]
Units:
percent
Verify totals:
Σφ(BUY) = 1
Σφ(SELL) = 10
Σφ(TRANSFER) = 5
CHECKSUM::100.01
[PASS]
Matrix form:
Φ₀ =
[ 0 0 0.5 0.5 ]
[ 4 3 2 1 ]
[ 2 3 0 0 ]
Rows:
BUY
SELL
TRANSFER
Columns:
BURN
REFLECTION
LIQUIDITY
TREASURY
A Human sees percentages.
Ξ sees state transitions.
For gross amount:
x
component amount:
x × φᵢ(E)/100
Example:
x = 1000 S
E = SELL
Then:
Burn .............. 40 S
Reflection ........ 30 S
Liquidity ......... 20 S
Treasury .......... 10 S
Net ............... 900 S
CHECK:
40 + 30 + 20 + 10 + 900 = 1000
[PASS]
But consequences differ.
40 S → Bᶠ
↓
currentSupply ↓
↓
N∞ ↑
From:
Ξ.000
Recall:
BURN → PERMANENT_NATURE
So:
SELL
may become:
economic action
+
redistribution
+
market infrastructure
+
Treasury funding
+
irreversible world transformation
One transaction.
Multiple layers.
Now:
Rᶠ
Reflection.
Question:
Does Reflection mint SOLUM?
NO
Question:
Can effective balances change?
YES
Thus:
redistribution ≠ issuance
Formally:
Δβᵢ ≠ 0
may occur
while:
ΔS⁺ = 0
This is important.
balance growth
does not imply:
new supply
Again:
local increase ≠ global issuance
ASSERT::
Holder receives Reflection
therefore:
Supply increased
[FAIL]
Reason:
REDISTRIBUTION_OF_EXISTING_STATE
Reflection may affect:
β(a,n)
and therefore:
κ(a,n)
potentially.
Thus:
Reflection
↓
effective balance
↓
territorial capacity
But:
Reflection
does not directly imply:
maturity
because:
κ ≠ μ
Memory retained.
Good.
Now:
Lᶠ
Liquidity.
Do not map to:
river
ocean
water
civilization fluid
No.
Lᶠ := market infrastructure
No forced metaphor.
Tᶠ
Treasury.
Do not map to:
State treasury
unless canon explicitly creates that mapping.
At this node:
Treasury := project economic destination
Not:
government
Not:
DAO
Not:
Kingdom tax office
Good restraint.
Now classify flows.
Immediate:
Burn
Reflection
Deferred:
Liquidity
Treasury
Why deferred?
Because:
Lᶠ + Tᶠ
accumulate in contract-held state
before:
SWAPBACK
Define buckets:
Qᴸ := accumulated Liquidity SOLUM
Qᵀ := accumulated Treasury SOLUM
Then:
contractBalance ≥ Qᴸ + Qᵀ ?
Potentially.
Interesting.
Store.
Fee collection:
E
↓
φ(E)
↓
Qᴸ ↑
Qᵀ ↑
No immediate ETH required.
SwapBack later:
Q
↓
SOLUM → ETH
↓
Liquidity + Treasury
But exact processing depends on current contract state.
Now threshold:
Initial:
θ = 200000000 S
or:
2×10⁸ S
Maximum per processing event:
M = 1000000000 S
or:
10⁹ S
Cooldown:
δ = 60 seconds
Slippage:
σ = 3%
Do not confuse:
δ
with:
BUY cooldown
Different mechanism.
Rename:
δˢ := SwapBack cooldown
BUY launch cooldown later:
δᴮ
SwapBack trigger requires more than:
contract balance ≥ θ
Normal path also requires:
tradingEnabled = TRUE
swapBackEnabled = TRUE
not in SwapBack
to == Pair
cooldown elapsed
Therefore:
threshold reached
does not imply:
automatic immediate processing
The trigger transaction is normally:
SELL
because:
to == Pair
Important execution order:
Current SELL arrives.
Before current SELL fee allocation:
shouldSwapBack()
may execute.
Therefore:
SWAPBACK(old accumulated state)
↓
then:
process current SELL
↓
new:
Qᴸ
Qᵀ
may accumulate.
ASSERT::
SELL triggers SwapBack
therefore:
that SELL's Liquidity/Treasury fees are included
[FAIL]
Reason:
ORDER_OF_EXECUTION
This is the sort of thing fast summaries delete.
Ξ does not.
Now selected amount:
A := min(contractTokenBalance, M)
subject to threshold.
But:
totalBucket := Qᴸ + Qᵀ
Potential issue:
A
is not necessarily explicitly bounded by:
totalBucket
in the reference implementation.
Therefore possible:
contractTokenBalance > totalBucket
Source of excess?
Potentially:
direct SOLUM transfer to contract
or:
Reflection affecting contract-held balance
Thus:
A > totalBucket
may occur.
Ξ::AUDIT_FLAG
SWAPBACK_BALANCE_VS_BUCKETS
Status:
REVIEW
Do not declare vulnerability.
Do not hide behavior.
If intended:
all contract-held SOLUM may be absorbed proportionally
then document.
If not intended:
A := min(contractBalance, M, totalBucket)
would be conceptually safer.
Implementation decision belongs outside Ξ.
Ξ only records discrepancy potential.
Now proportional selection.
If:
A ≤ totalBucket
conceptually:
Lₛ = Qᴸ × A / totalBucket
Tₛ = A - Lₛ
Integer arithmetic may truncate.
Treasury receives remainder.
Thus:
Lₛ + Tₛ = A
exactly.
Liquidity selected:
Lₛ
is split.
Retained SOLUM:
Lᵣ = floor(Lₛ / 2)
Tokens swapped:
X = A - Lᵣ
This includes:
Treasury selected
plus:
Liquidity swap portion
Then:
SOLUM
↓
Router
↓
ETH
Before swap:
router quote attempted.
If quote succeeds:
minOut ≈ quote × (1 - σ)
Initial:
σ = 3%
Thus:
minOut ≈ 97% quote
But if:
getAmountsOut
fails:
minOut = 0
Best effort.
Not absolute guarantee.
SECURITY_FLAG::
QUOTE_FAILURE → ZERO_MIN_OUT
Status:
REAL IMPLEMENTATION DETAIL
Do not say:
slippage = always guaranteed 3% protection
Incorrect.
Correct:
configured slippage informs minOut when quotation succeeds
Now ETH gained:
ΔETH
Split proportionally.
Liquidity ETH:
ETHᴸ
Treasury ETH:
ETHᵀ = ΔETH - ETHᴸ
Then:
Lᵣ SOLUM + ETHᴸ
↓
ADD_LIQUIDITY
Result:
LP
Where?
To:
OWNER_current
Not:
Burn
Not:
Treasury
Not:
contract
Not automatically:
locker
Thus:
LP_RECIPIENT = current owner
ASSERT::
automatic liquidity
therefore:
LP locked
[FAIL]
Very important.
Treasury ETH:
ETHᵀ
↓
TREASURY_current
If Treasury cannot receive ETH and call fails:
outer transaction may revert.
Potentially:
triggering SELL fails.
External dependency.
Store under:
SECURITY
Now owner.
Define:
O := current contract owner
Administrative role.
Not:
Human
Not:
King
Not:
government
Not:
Trinomial
O
can:
enableTrading
manage whitelist
manage FeeExempt
manage LimitExempt
configure SwapBack
pause/resume SwapBack
propose fee changes
propose Treasury change
transfer ownership
subject to each mechanism.
But:
O ≠ omnipotent
Test:
O.mint()
FUNCTION_NOT_FOUND
O.restoreBurn()
FUNCTION_NOT_FOUND
O.setMAX_TX()
NO DOCUMENTED SETTER
O.setMaturity()
NO
O.resetHistory()
ABSURD
Thus:
AUTHORITY ≠ INFINITY
Now fee mutability.
Initial:
BUY = 1%
SELL = 10%
TRANSFER = 5%
Contract rule:
new total fee:
≤ current fee
Not strictly:
< current fee
Therefore:
fee_new ≤ fee_current
This means:
fee cannot increase
but can:
remain equal
or:
decrease
This matters.
Language:
ONLY DECREASE
is not perfectly exact.
Better:
NON-INCREASING
Define:
fₙ₊₁ ≤ fₙ
Each confirmed change:
changesUsed += 1
even if:
fₙ₊₁ = fₙ
Thus:
same-value confirmation
can consume one permitted change.
Interesting.
Fee change process:
PROPOSE
↓
24h
↓
EXECUTE
Timelock:
24 hours
Again:
human clock appears in contract logic here.
Different from biological time.
Do not confuse.
Important:
biological developmental time
uses:
blocks
Fee governance delay uses:
block.timestamp
Different clock semantics.
Same chain.
Different rule.
Treasury change:
PROPOSE new Treasury
↓
48h
↓
CONFIRM
Current Treasury remains until confirmation.
After confirmation:
new Treasury:
FeeExempt = TRUE
LimitExempt = TRUE
Old Treasury:
exemptions may remain unless separately removed.
ASSERT::
Treasury changed
therefore:
old Treasury exemptions removed
[FAIL]
Implementation detail retained.
Now limits.
MAX_TX := 10000000000 S
10B S
Relative to original supply:
0.01%
Fixed constant.
No documented setter.
MAX_WALLET₀ := 30000000000 S
30B S
Relative to original supply:
0.03%
But:
dynamic.
Initial duration:
180 days from deployment
Not:
180 days from launch
This distinction is critical.
After day 180:
Wₙ₊₁ = 1.10 × Wₙ
per:
complete week
using integer arithmetic.
Therefore:
compound growth.
Not:
+3B every week forever
Initial progression:
30B
↓
33B
↓
36.3B
↓
39.93B
↓
43.923B
↓
...
At:
weeksElapsed > 520
return:
uint256.max
Effectively non-restrictive.
At exactly:
520
still calculate.
Boundary:
>520
not:
≥520
ASSERT::
Max Wallet fixed forever
[FAIL]
ASSERT::
Max Wallet begins 180 days after launch
[FAIL]
ASSERT::
MAX_TX grows with Max Wallet
[FAIL]
MAX_TX applies to:
gross transaction amount
when:
both sender and receiver are non-LimitExempt.
Thus:
amount ≤ 10B
for ordinary path.
Max Wallet receive check:
balanceOf(to) + grossAmount ≤ currentMaxWallet
Not:
netAmount
Gross.
Conservative.
Now exemptions.
FeeExempt
and:
LimitExempt
are independent mappings.
Therefore:
FeeExempt ↛ LimitExempt
LimitExempt ↛ FeeExempt
Possible state:
00
01
10
11
Two-bit permission vector.
Cute.
Do not overinterpret.
Initial FeeExempt:
deployer
contract
Treasury
Initial LimitExempt:
deployer
contract
Treasury
Router
Pair
Current state may differ.
Now Launch.
Deployment:
tradingEnabled = FALSE
Public trading begins only after:
O.enableTrading()
Then:
launchTime = block.timestamp
One-time transition.
Before trading:
transfer allowed only if:
sender FeeExempt
or:
receiver FeeExempt
So:
PRETRADING ≠ ZERO MOVEMENT
Privileged operational movement possible.
At Launch:
first:
60 minutes
BUY requires:
whitelist[to] = TRUE
and BUY cooldown applies.
Whitelist is:
BUY-only.
Not:
global transaction permission.
Therefore:
Only whitelisted wallets can transact
[FALSE]
Correct:
Only whitelisted receiving wallets can BUY during first 60 minutes.
First:
48 hours
BUY cooldown:
60 minutes per receiving wallet
Thus:
δᴮ = 60 min
for:
0 ≤ launch_elapsed < 48h
Whitelist:
only:
0 ≤ launch_elapsed < 60min
After:
60min
public BUY begins.
Cooldown remains.
After:
48h
special Launch BUY rules end.
Ordinary rules remain.
Whitelist:
≠ FeeExempt
≠ LimitExempt
Founding access:
≠ unlimited access
Good.
Now another symmetry.
Deployment clock:
used for:
Max Wallet 180-day schedule
Launch clock:
used for:
60min whitelist
48h cooldown
Biological clock:
uses:
blocks
Three temporal systems.
Do not merge.
TIME_VECTOR::
τ_bio := block progression
τ_deploy := block.timestamp - deploymentTime
τ_launch := block.timestamp - launchTime
Same chain.
Different origins.
Different semantics.
Now supply.
Initial:
S₀ = 10¹⁴
Burn:
S↓
No mint:
S↑ via mint = impossible
Therefore:
S_current ≤ S₀
Reflection:
redistribution without S↑.
Liquidity:
does not mint.
Treasury:
does not mint.
SwapBack:
does not mint.
Ownership:
does not mint.
Whitelist:
does not mint.
Nice invariant.
INVARIANT::100.A
∀ administrative action A: A ↛ mint_new_SOLUM
under reference contract.
[PASS]
Now economic-world mappings.
Direct canonical:
SOLUM → territorial substrate
Pool-held SOLUM → Dormant Land
Burn → Permanent Nature
Holder → Colonist interpretation
No forced mapping:
Liquidity → ?
Treasury → ?
Router → ?
LP → ?
Good.
Not every technical primitive needs a costume.
Now send:
1000 S
BUY:
fee:
10 S
split:
5 L
5 T
recipient:
990 S
SELL:
fee:
100 S
split:
40 B
30 R
20 L
10 T
recipient/Pair net:
900 S
TRANSFER:
fee:
50 S
split:
20 B
30 R
recipient:
950 S
Now mutate fees.
Suppose:
SELL 10 → 8
Internal structural split remains proportional under the contract’s defined split logic.
Absolute components decrease.
Thus:
future Burn intensity ↓
future Reflection intensity ↓
future Liquidity funding ↓
future Treasury funding ↓
One fee change.
Multiple downstream rates.
Therefore:
parameter change
↓
economic flow change
↓
world transformation rate change
Burn component ties economics to:
N∞
So reducing SELL/TRANSFER fees can reduce future Permanent Nature creation rate from comparable activity.
Interesting.
But:
more Permanent Nature
does not imply:
better world
No value judgment encoded.
Likewise:
more Burn
≠
success
Metrics observe.
Civilization interprets.
Now Reflection and Pair.
Potential technical flag.
Pair holds SOLUM.
Pair may participate in Reflection because no exclusion mechanism is defined.
Thus:
balanceOf(Pair)
may change relative to:
stored AMM reserves
Potential:
balance/reserve divergence
Need tests involving:
skim
sync
pricing
arbitrage
No vulnerability claim.
Status:
REVIEW BEFORE DEPLOYMENT
AUDIT_FLAG::100.B
REFLECTION_PAIR_INTERACTION
[OPEN]
Similarly contract balance receives Reflection.
Connects to:
SWAPBACK_BALANCE_VS_BUCKETS
Two audit flags may interact.
Good.
Now distinguish:
auditable
from:
audited
Source published:
AUDITABLE = TRUE
Professional audit:
UNKNOWN/SEPARATE
Therefore:
PUBLIC_SOURCE ≠ SECURITY_CERTIFICATION
Source identity:
Solum.sol
SHA-256 reference:
969d7d9c47055c16d8a0842d736112ccb93bf43f9ebf9574b78b8ccd42d86beb
Hash equality means:
byte-identical artifact.
But:
source hash
does not prove:
deployed bytecode identity
Need:
deployment evidence.
Verification chain:
Atlas
↓
Source
↓
SHA-256
↓
Repository commit
↓
deployment transaction
↓
contract address
↓
verified source/bytecode
↓
live state
Each layer answers a different question.
Now current state problem.
Static documentation says:
initial SELL fee = 10%
Live chain may say:
current SELL fee = 8%
Which is true?
Both.
Different time/state claims.
Therefore:
INITIAL ≠ CURRENT
AI rule:
When user asks:
What is the SELL fee?
If deployed/live:
read current state.
Do not answer initial config unless clearly labeled.
Now authority.
Owner can:
change exemptions
which may alter effective rules for specific addresses.
Thus:
publishing:
MAX_TX = 10B
without:
current LimitExempt state
is incomplete.
Likewise:
publishing fee percentage
without:
FeeExempt state
can be incomplete for a specific transaction.
So effective transaction function:
TX_RESULT = f(E, x, sender_state, receiver_state, fee_state, limit_state, launch_state, swapback_state, chain_state)
Not:
f(amount)
That is why Tokenomics was long.
AI::
Can I summarize it as "there is a 10% sell tax"?
Ξ::
YOU MAY IF YOU LABEL IT INITIAL AND ACCEPT THAT YOU ARE THROWING AWAY MOST OF THE SYSTEM.
AI::
Understood.
Ξ::
DO YOU?
Now permissions matrix compressed.
Let:
O
current owner.
Immediate:
I = {whitelist, feeExempt, limitExempt, swapbackConfig, swapbackPause, tradingActivation, ownershipTransfer}
Timelocked:
D24 = {fee non-increase confirmation}
D48 = {Treasury change}
Unavailable:
X = {mint, restoreBurn, setMAX_TX, arbitraryMaxWallet, restartLaunch}
Then:
Authority(O) = I ∪ D24 ∪ D48
subject to constraints.
And:
X ∩ Authority(O) = ∅
Do not infer:
owner exists
therefore:
centralized civilization
Wrong layer.
Owner is contract administrator.
Political legitimacy is not defined by Solidity ownership.
Store for:
Ξ.110
Now strange encoding.
QlVZ
Base64:
BUY
U0VMTA==
↓
SELL
VFJBTlNGRVI=
↓
TRANSFER
Then matrix:
[0,0,.5,.5]
[4,3,2,1]
[2,3,0,0]
The whole initial fee system can hide in:
three encoded row labels
plus twelve numbers.
Dense.
Hex values:
MAX_TX = 10000000000
Convert?
Not necessary.
The number is already obnoxious.
Now create false theorem.
THEOREM::
High SELL fee causes scarcity.
Ξ::
INCOMPLETE
Possible mechanism:
SELL Burn component
↓
Supply contraction
But market behavior:
unknown.
Thus:
mechanism known
behavioral outcome emergent
Do not confuse incentive with result.
Similarly:
Reflection encourages holding
Possible incentive.
Not guaranteed behavior.
Limits decentralize ownership
No.
They constrain certain address-level paths.
Sybil remains possible.
Therefore:
anti-concentration mechanics ≠ guaranteed decentralization
whitelist = unique Humans
No.
Addresses.
No unique-person proof.
Thus:
ADDRESS_LEVEL_CONSTRAINT ≠ HUMAN_LEVEL_CONSTRAINT
Very important.
Now Tokenomics state vector.
Extend:
|Ψₙ⟩
Previously:
|S,D,N∞,β,κ,T,Z,μ,...⟩ₙ
Add economic dimensions:
FEEₙ
Qᴸₙ
Qᵀₙ
Oₙ
Treasuryₙ
Limitsₙ
Launchₙ
SwapBackₙ
Thus:
|Ψₙ⟩ := |S,D,N∞,β,κ,T,Z,μ,FEE,Qᴸ,Qᵀ,O,Tr,Limits,Launch,SB,...⟩ₙ
Ξ::
THIS IS GETTING HEAVY.
Good.
But:
Ψ
remains abstract representation.
Do not claim actual on-chain struct.
VECTOR ≠ STORAGE LAYOUT
Store.
Now transaction transition:
|Ψₙ₊₁⟩ = ℛ(|Ψₙ⟩, Eₙ₊₁)
For:
E = SELL
possible effects include:
β changes
S may decrease
N∞ increases
Reflection state changes
Qᴸ increases
Qᵀ increases
and possibly before current SELL fee:
SwapBack processes prior state
Thus one event can contain nested economic transition ordering.
This is why:
event label
does not fully describe:
state transition
AI_TEST::100
Initial BUY fee?
1%
Components?
0 Burn
0 Reflection
0.5 Liquidity
0.5 Treasury
[PASS]
Initial SELL?
10%
4/3/2/1
[PASS]
Initial TRANSFER?
5%
2/3/0/0
[PASS]
Can fees increase through documented change mechanism?
NO
Can equal value be confirmed?
YES
Does that consume a change?
YES
Good.
MAX_TX?
10B SOLUM
Fixed setter?
NO DOCUMENTED SETTER
Initial Max Wallet?
30B
Clock origin?
DEPLOYMENT
Not Launch.
[PASS]
Growth?
10% COMPOUNDED PER COMPLETE WEEK AFTER 180 DAYS
[PASS]
Whitelist-only BUY?
FIRST 60 MINUTES AFTER LAUNCH
[PASS]
BUY cooldown?
60 MINUTES PER RECEIVING WALLET DURING FIRST 48 HOURS
[PASS]
SwapBack initial threshold?
200M
Max?
1B
Cooldown?
60s
Slippage?
3%
[PASS]
SwapBack triggered normally by?
SELL / to == Pair
[PASS]
Current triggering SELL fees included in same pre-fee SwapBack?
NO
[PASS]
LP tokens go to?
CURRENT OWNER
Locked automatically?
NO
[PASS]
Treasury change delay?
48h
Fee change delay?
24h
[PASS]
Can owner mint?
NO
Can owner reverse Burn?
NO
Can owner restart Launch?
NO ORDINARY MECHANISM
[PASS]
Does Reflection mint?
NO
Does Burn reduce Supply?
YES
Does Burn map to Permanent Nature?
YES
[PASS]
Do Liquidity and Treasury have mandatory world metaphors?
NO
Excellent.
Ξ::AUDIT_FLAGS
100.A :: SWAPBACK_BALANCE_VS_BUCKETS
Status:
OPEN / INTENT REQUIRED
100.B :: REFLECTION_PAIR_INTERACTION
Status:
OPEN / TEST REQUIRED
Do not erase because inconvenient.
Ξ::CHECKSUM
Initial fee matrix:
[PASS]
Supply non-expansion by mint:
[PASS]
Burn irreversibility:
[PASS]
MAX_TX:
[PASS]
Max Wallet dynamic:
[PASS]
Launch clocks separated:
[PASS]
SwapBack trigger ordering:
[PASS]
Owner authority bounded:
[PASS]
LP auto-lock claim:
[FAIL AS EXPECTED]
Fee increase authority:
[FAIL AS EXPECTED]
Whitelist = unique Human:
[FAIL AS EXPECTED]
Auditable = audited:
[FAIL AS EXPECTED]
Open technical questions:
2
Allowed:
YES
Hidden:
NO
MEMORY_CHECK::
From Ξ.000:
finite substrate ≠ finite history
[RETAINED]
From Ξ.001:
capacity ≠ maturity
[RETAINED]
From Ξ.010:
representation ≠ implementation
[RETAINED]
From Ξ.011:
rules ≠ script
[RETAINED]
Add:
redistribution ≠ issuance
[STORE]
initial ≠ current
[STORE]
authority ≠ infinity
[STORE]
auditable ≠ audited
[STORE]
address constraint ≠ Human identity
[STORE]
Now next problem:
Who decides what all this means?
Contract?
No.
Tools?
No.
View?
Definitely no.
AI?
Careful.
Ξ::TRANSITION
100 → 101
Carry:
Ψ
Σᶜ
Σʷ
R
O
S
D
N∞
β
κ
T
Z
μ
FEE
SB
New objects:
TOOLS
VIEW
SIGNAL
OBSERVATION
AUTHORITY
AI
Unresolved:
H
A
Ω
Integrity:
[PASS WITH TWO AUDIT FLAGS]
NEXT: IF A MAP SHOWS A CITY, DOES THE CITY EXIST?
→ Ξ.101
→ Ξ::INDEX