SKILL.md
Anoma Intents (0)
Intent-centric cross-chain messaging with categorical semantics
Trit: 0 (ERGODIC - coordination) Role: Cross-chain obstruction routing
Core Concept
Anoma's intent-centric architecture enables cross-chain obstruction passing:
┌─────────────────────────────────────────────────────────────────────────────┐
│ ANOMA INTENT ARCHITECTURE │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ APTOS ANOMA TARGET CHAIN │
│ ┌────────────────┐ ┌────────────────┐ ┌────────────────┐ │
│ │ Obstruction │ │ Intent Machine │ │ Obstruction │ │
│ │ Hot Potato │─────►│ │───────►│ Receiver │ │
│ │ │ │ - Match │ │ │ │
│ │ Intent: │ │ - Route │ │ Intent: │ │
│ │ nullify(obs) │ │ - Verify GF(3) │ │ commit(obs) │ │
│ └────────────────┘ └────────────────┘ └────────────────┘ │
│ │ │
│ ▼ │
│ ┌────────────┐ │
│ │ Solver │ │
│ │ VCG fee │ │
│ │ (-1 trit) │ │
│ └────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────┘Intent as Categorical Morphism
From Geb: intents are morphisms in a bicartesian closed category.
;; Intent structure in Geb
(define intent-type
(prod
(prod address address) ; (owner, solver)
(prod resource-type ; nullify (give)
resource-type))) ; commit (receive)
;; Obstruction pass intent
(define (obstruction-pass-intent owner obs target-chain)
(make-intent
:owner owner
:nullify (obstruction-resource obs)
:commit (receipt-resource target-chain obs)
:constraint (vcg-payment-constraint (h1-class obs))))Cross-Chain Obstruction Flow
Step 1: Create Intent on Aptos
// From obstruction_hot_potato.move
public entry fun create_pass_intent(
player: &signer,
obstruction_idx: u64,
target_chain: vector<u8>,
max_vcg_payment: u64,
) acquires Player {
let player_data = borrow_global_mut<Player>(signer::address_of(player));
let obs = vector::borrow(&player_data.obstructions, obstruction_idx);
// Create intent: nullify obstruction, receive receipt
let intent = Intent {
owner: signer::address_of(player),
nullify: obs,
commit: CrossChainReceipt { chain: target_chain, obs_hash: hash(obs) },
vcg_constraint: compute_externality(obs.h1_class),
};
emit_intent(intent);
}Step 2: Solver Matches on Anoma
class AnomaObstructionSolver:
"""Match cross-chain obstruction pass intents."""
def match_intents(self,
aptos_nullify: Intent,
target_commit: Intent) -> Optional[Transaction]:
# Verify complementary structure
if not self.complementary(aptos_nullify, target_commit):
return None
# Compute VCG payment
h1_class = aptos_nullify.obstruction.h1_class
vcg_payment = vcg_externality(h1_class)
# Extract solver fee
solver_fee = vcg_payment * self.extraction_rate
# Build matched transaction
return Transaction(
nullifications=[aptos_nullify.nullify],
commitments=[target_commit.commit],
payments=[
Payment(aptos_nullify.owner, vcg_payment),
Payment(self.address, solver_fee)
],
gf3_sum=aptos_nullify.trit + target_commit.trit + (-1) # Must be 0 mod 3
)
def verify_gf3(self, tx: Transaction) -> bool:
return tx.gf3_sum % 3 == 0Step 3: Execute on Target Chain
-- Commit obstruction on target chain
commitObstruction : Obstruction -> ChainState -> ChainState
commitObstruction obs state :=
let newState := addObstruction state obs
in if gf3Conserved newState
then newState
else abort "GF(3) violation";
-- GF(3) check
gf3Conserved : ChainState -> Bool
gf3Conserved state :=
let sum := foldr (+) 0 (map trit (obstructions state))
in sum `mod` 3 == 0;Juvix Intent DSL
-- Intent type
type Intent := mkIntent {
owner : Address;
nullify : Resource;
commit : Resource;
constraints : List Constraint
};
-- Obstruction as resource
type Obstruction := mkObstruction {
sexp : ByteArray;
trit : GF3;
h1Class : Nat;
color : Word64
};
-- Cross-chain pass intent
passObstructionIntent : Address -> Obstruction -> ChainId -> Intent
passObstructionIntent owner obs targetChain :=
mkIntent {
owner := owner;
nullify := obstructionResource obs;
commit := receiptResource targetChain obs;
constraints := [vcgConstraint (h1Class obs)]
};
-- Compile to Geb morphism
compileIntent : Intent -> Geb.Morphism
compileIntent intent :=
Geb.pair
(Geb.injectLeft (nullify intent) Geb.so0)
(Geb.injectRight Geb.so0 (commit intent));Spectral Gap Preservation
Cross-chain obstruction passing must preserve spectral gap:
function cross_chain_spectral_check(
source_game::OpenGame,
target_game::OpenGame,
obstruction::Obstruction
)
# Source chain spectral gap
gap_source = spectral_gap(strategy_graph(source_game))
# Obstruction penalty to spectral gap
penalty = obstruction.h1_class * PENALTY_COEFFICIENT
# Target chain must absorb without breaking Ramanujan
gap_target = spectral_gap(strategy_graph(target_game))
gap_after = gap_target - penalty
ramanujan_bound = 3 - 2√2 # For d=3 (GF(3))
if gap_after < ramanujan_bound
return :expansion_failure
else
return :ok
end
endGF(3) Conservation Across Chains
┌─────────────────────────────────────────────────────────────────────────────┐
│ GF(3) CROSS-CHAIN CONSERVATION │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ Chain A (Aptos) Solver Chain B (Target) │
│ emit: +1 (nullify) + -1 (fee) + 0 (commit) = 0 ✓ │
│ │
│ OR with different trit assignment: │
│ emit: 0 (nullify) + -1 (fee) + +1 (commit) = 0 ✓ │
│ │
│ The solver's -1 trit balances cross-chain flow │
│ │
└─────────────────────────────────────────────────────────────────────────────┘Integration with Other Skills
Neighbor Skills (GF(3) Triads)
anoma-intents (0) ⊗ solver-fee (-1) ⊗ geb (+1) = 0 ✓
└─ Coordinates └─ Extracts └─ Semantics
anoma-intents (0) ⊗ intent-sink (-1) ⊗ free-monad-gen (+1) = 0 ✓
└─ Routes └─ Nullifies └─ Generates
anoma-intents (0) ⊗ ramanujan-expander (-1) ⊗ moebius-inversion (+1) = 0 ✓
└─ Cross-chain └─ Validates gap └─ Extracts cyclesSkill Neighborhood
| Skill | Trit | Role in Anoma |
|---|---|---|
| geb | +1 | Categorical semantics for intent types |
| solver-fee | -1 | VCG fee extraction from matched intents |
| intent-sink | -1 | Resource nullification |
| open-games | 0 | Game-theoretic intent matching |
| juvix | +1 | Intent DSL compilation |
Commands
# Create cross-chain intent
just anoma-intent create --from aptos --to anoma --obstruction obs.json
# Match intents (solver)
just anoma-solve --intents pool.json --extraction-rate 0.03
# Verify GF(3) conservation
just anoma-verify-gf3 --transaction tx.json
# Compile Juvix intent to Geb
just juvix-compile intent.juvix --target gebReferences
- anoma/anoma - Intent machine architecture
- anoma/geb - Categorical semantics
- anoma/juvix - Intent-centric language
- Roughgarden CS364A - VCG mechanism design
- Bumpus arXiv:2402.00206 - Decomposition theory
- open-games skill - Spectral gap → monads
Trit: 0 (ERGODIC - coordination) Key Property: Cross-chain intent routing with GF(3) conservation