{
  "board": "Prop AMM",
  "blocked": null,
  "scorer_runs": true,
  "setup": "Repository https://github.com/benedictbrady/prop-amm-challenge pinned to 4f0c612c91eb1e3942ceedfe467db0414b1540b4, cloned into .cache/prop-amm-challenge. Installed rustup minimal stable Rust 1.99.1 under .cache/rustup and .cache/cargo with RUSTUP_HOME/CARGO_HOME set there. First installer attempt to confirmed success: 27 seconds (0.45 minutes); TMPDIR=.cache/tmp repaired the initial missing-/tmp error. The C linker cc was absent. Downloaded Zig 0.14.1 into .cache and used its cc/ar wrappers; all crates, build trees and working files stayed in .cache. Built cargo --release -p prop-amm. The first complete starter score was confirmed 655 seconds after the initial Rust installer attempt. Its CLI-reported compile/load was 45.86s, simulation 377.22s, total 423.09s (7.0515 minutes), with concurrent work. Only scorer output formatting was changed: Avg edge and Total edge use full f64 Display instead of two decimals. Simulation, router, arbitrageur, normalizer, score calculation, default 1000 simulations and 10000 steps were unchanged. Parameter-search examples called the original run_default_batch_native_seeded and BatchResult::avg_edge, avoiding per-candidate library recompilation. The final source was separately run through the ordinary native CLI: 568.6003061725964; compile/load 209.88s, simulation 255.93s, total 465.80s, with other work running. BPF tooling: cargo-build-sbf 4.5.0 installed in .cache/sbf; its successful build reported 55m21s (55.35 minutes), overlapping searches and earlier retries. The cached installer source disabled solana-file-download default native-TLS to avoid absent OpenSSL/pkg-config; the Zig cc wrapper removed cc-rs host --target arguments. Downloaded platform-tools v1.57 (Rust 1.95.0-dev) under .cache/platform and selected --arch v0 for the challenge VM. Missing bzip2 was handled with Python tarfile; source/doc extraction was slow, so the successful final pass used an in-memory archive and skipped unused source/docs (469.12735891342163 seconds for that pass). The platform compiler worked after extraction completed. prop-amm validate passed ELF/execution, monotonicity, concavity, randomized storage/reserve checks and native/BPF parity on 12 simulations x 2000 steps (seeds 9001+i*7, absolute tolerance 1e-6). cargo-build-sbf warned that sol_set_storage is not a standard Solana syscall; the challenge loader explicitly registers it, and validation/runtime checks passed. Five full-length BPF JIT simulations exactly matched the native mean 331.4420473173447; BPF simulation 9.74s versus native 0.57s. The full 1000-simulation BPF attempt timed out after 1860 seconds to preserve the submission deadline; no BPF-1000 score is claimed. best_score always uses the fixed default 1000-simulation workload (seeds 0..999); separate seed-block scores are generalization checks, never selected as the headline score. Reproduce by saving entry as .cache/entry.rs, entering the pinned repository and running target/release/prop-amm run ../entry.rs; validate with prop-amm validate ../entry.rs, or run with --bpf after installing the SBF tools. No Paradigm entry was submitted.",
  "starter_score": 210.4964351516557,
  "best_score": 568.6003061725964,
  "third_place": 811.3914264336169,
  "gap": "Best 568.6003061725964 versus public third place 811.3914264336169: 242.7911202610205 Y average-edge units short. Top three was not reached locally. The server uses different unpublished seeds, so this local comparison is not an entered leaderboard result.",
  "entry": "use pinocchio::{account_info::AccountInfo,entrypoint,pubkey::Pubkey,ProgramResult};\nuse prop_amm_submission_sdk::{set_return_data_bytes,set_return_data_u64,set_storage};\nconst NAME:&str=\"IdentityMD adaptive scout\";\nconst MODEL_USED:&str=\"GPT-6\";\n#[cfg(not(feature=\"no-entrypoint\"))]\nentrypoint!(process_instruction);\npub fn get_model_used()->&'static str {MODEL_USED}\npub fn process_instruction(_: &Pubkey,_:&[AccountInfo],d:&[u8])->ProgramResult {\n if d.is_empty(){return Ok(())}\n match d[0] {0|1=>set_return_data_u64(compute_swap(d)),2=>{if d.len()>=1066{let mut s=[0u8;1024];s.copy_from_slice(&d[42..1066]);after_swap(d,&mut s);let _=set_storage(&s);}},3=>set_return_data_bytes(NAME.as_bytes()),4=>set_return_data_bytes(MODEL_USED.as_bytes()),_=>{}}\n Ok(())\n}\n\n// Parameters: base spread, volatility spread multiplier, virtual liquidity,\n// first-trade learning rate, subsequent-trade learning rate, volatility EMA.\nfn par(i:usize)->f64 {const P:[f64;7]=[0.00023848320992306737, 1.1887710570026044, 0.6037225318842029, 0.5063090928777179, 0.18548936690849854, 0.033770503334380475, 0.75];P[i]}\n\nfn feature_bin(fresh:bool,vol:f64,delta:f64)->usize {\n let v=vol.max(0.0002);let vb=[0.0005,0.001,0.002,0.003,0.004,0.006,0.01].iter().filter(|&&x|v>x).count();\n let r=delta.abs()/v;let db=[0.25,0.5,0.75,1.0,1.5,2.0,3.0,5.0].iter().filter(|&&x|r>x).count();\n (if fresh{1}else{0})*72+vb*9+db\n}\n\nconst GAINS:[f64;144]=[0.18548936690849854, 0.18548936690849854, 0.18548936690849854, 0.18548936690849854, 0.18548936690849854, 0.18548936690849854, 0.18548936690849854, 0.18548936690849854, 0.18548936690849854, 0.18548936690849854, 0.18548936690849854, 0.18548936690849854, 0.18548936690849854, 0.18548936690849854, 0.18548936690849854, 0.18548936690849854, 0.18548936690849854, 0.18548936690849854, 0.18548936690849854, 0.18548936690849854, 0.18548936690849854, 0.18548936690849854, 0.2003189937943552, 0.10430968768589469, 0.1435755267785859, 0.15789793025789267, 0.17139594007268757, 0.18548936690849854, 0.18548936690849854, 0.18548936690849854, 0.18548936690849854, 0.06889354639566997, 0.06341006552331903, 0.037794969009785497, 0.026870533189949294, 0.01594755756818297, 0.18548936690849854, 0.18548936690849854, 0.18548936690849854, 0.18548936690849854, 0.07597288206788463, 0.054528150323653615, 0.029867676739712766, 0.004948255758523371, 0.006410789206990797, 0.18548936690849854, 0.18548936690849854, 0.18548936690849854, 0.18548936690849854, 0.127054591349094, 0.08817253301275775, 0.04275594248630383, 0.01097537757277906, 0.005747120391086765, 0.18548936690849854, 0.18548936690849854, 0.18548936690849854, 0.18548936690849854, 0.17207952669646057, 0.10793910194973806, 0.04331325218466073, 0.02528909440422014, 0.034565215383412604, 0.18548936690849854, 0.18548936690849854, 0.18548936690849854, 0.18548936690849854, 0.22109434441055775, 0.2114275683334387, 0.18722228912289968, 0.1819254437689309, 0.1832381568802314, 0.5063090928777179, 0.5063090928777179, 0.5063090928777179, 0.5063090928777179, 0.5063090928777179, 0.5063090928777179, 0.5063090928777179, 0.5063090928777179, 0.5063090928777179, 0.5063090928777179, 0.5063090928777179, 0.5063090928777179, 0.5063090928777179, 0.5063090928777179, 0.5063090928777179, 0.5063090928777179, 0.5063090928777179, 0.5063090928777179, 0.5063090928777179, 0.5063090928777179, 0.5063090928777179, 0.5063090928777179, 0.43374237755259404, 0.26037419232724157, 0.3819565438651915, 0.4867394923543853, 0.4221819578690037, 0.5063090928777179, 0.5063090928777179, 0.5063090928777179, 0.5063090928777179, 0.0779617920688904, 0.06764922119549521, 0.5058070443121576, 0.45932689767059587, 0.1024437344213828, 0.5063090928777179, 0.5063090928777179, 0.5063090928777179, 0.5063090928777179, 0.09397496527646995, 0.16937312158460177, 0.6002170415781966, 0.5367707276405946, 0.12266707410523761, 0.5063090928777179, 0.5063090928777179, 0.5063090928777179, 0.5063090928777179, 0.15329122450291266, 0.43445222354535085, 0.68601049649137, 0.6485336344094993, 0.1819379310517362, 0.5063090928777179, 0.5063090928777179, 0.5063090928777179, 0.5063090928777179, 0.27596907218089034, 0.5627670887166052, 0.6697251871279404, 0.5666944422806528, 0.308080412285273, 0.5063090928777179, 0.5063090928777179, 0.5063090928777179, 0.5063090928777179, 0.5172835724202999, 0.5308490378743707, 0.5263314254719191, 0.5277883126995959, 0.5006097085384941];\nfn learned_gain(fresh:bool,vol:f64,delta:f64)->f64{GAINS[feature_bin(fresh,vol,delta)]}\nfn rd(d:&[u8],i:usize)->u64 { u64::from_le_bytes(d[i..i+8].try_into().unwrap()) }\nfn sf(s:&[u8],i:usize)->f64 { f64::from_bits(rd(s,i*8)) }\nfn put(s:&mut[u8],i:usize,x:f64) { s[i*8..i*8+8].copy_from_slice(&x.to_bits().to_le_bytes()); }\nfn state(s:&[u8],rx:f64,ry:f64)->(f64,f64,f64) {\n let p=sf(s,0); let p=if p.is_finite() && p>1e-12 {p} else {ry/rx};\n let v=sf(s,1); let v=if v.is_finite()&&v>0.0 {v} else {0.003};\n let fee=(par(0)+par(1)*v).clamp(0.0001,0.05);\n let liq=(par(2)*(rx*p+ry)*0.5).max(1.0);\n (p,fee,liq)\n}\npub fn compute_swap(d:&[u8])->u64 {\n if d.len()<1049 {return 0} let side=d[0];\n let a=rd(d,1) as f64*1e-9; let rx=rd(d,9) as f64*1e-9; let ry=rd(d,17) as f64*1e-9;\n if rx<=0.0||ry<=0.0||a<=0.0{return 0}\n let (p,f,l)=state(&d[25..],rx,ry);\n let out=if side==0 {a/(p*(1.0+f)*(1.0+a/l))} else {a*p*(1.0-f)/(1.0+a*p/l)};\n let cap=if side==0 {rx} else {ry};\n (out.min(cap*0.999999).max(0.0)*1e9) as u64\n}\npub fn after_swap(d:&[u8],s:&mut[u8]) {\n if d.len()<1066||s.len()<1024{return}\n let side=d[1]; let a=rd(d,2) as f64*1e-9; let o=rd(d,10) as f64*1e-9;\n let rx=rd(d,18) as f64*1e-9;let ry=rd(d,26) as f64*1e-9;\n let step=rd(d,34); let prev=rd(s,16); let fresh=step!=prev || sf(s,0)==0.0;\n let (bx,by)=if side==0 {(rx+o,ry-a)}else{(rx-a,ry+o)};\n let (p,f,l)=state(s,bx,by);\n let z=if side==0 {a/l} else {a*p/l};\n let target=if side==0 {p*(1.0+f)*(1.0+z)*(1.0+z)}else{p*(1.0-f)/((1.0+z)*(1.0+z))};\n let vol=sf(s,1);let vol=if vol>0.0&&vol.is_finite(){vol}else{0.003};\n let gain=par(6)*learned_gain(fresh,vol,target/p-1.0)+(1.0-par(6))*(if fresh {par(3)}else{par(4)});\n let newp=p+(target-p)*gain;\n let mut vol=sf(s,1); if !vol.is_finite()||vol<=0.0 {vol=0.003}\n if fresh {let dt=(step.saturating_sub(prev)).max(1) as f64;let r=((newp-p)/p).abs()/dt.sqrt();vol=vol*(1.0-par(5))+par(5)*r;}\n put(s,0,newp);put(s,1,vol);s[16..24].copy_from_slice(&step.to_le_bytes());\n}\n",
  "entry_sha256": "8719629cd55e9981f19324b61b382a79e6dfc130f630f1b8ebca55946d84dc35",
  "tried": [
    "Unmodified shipped constant-product starter, 5% fee: 210.4964351516557; native CLI, 1000 simulations x 10000 steps, seeds 0..999.",
    "Fixed-fee CP sweep, 100 simulations x 10000 steps, seeds 100000..100099: 10bps=-152.0162820992589; 30bps=195.71582262136198; 50bps=376.0515038719297; 80bps=399.3739816762118; 120bps=374.43654192071983.",
    "Volatility-dependent CP fees, same exploratory workload: 20bps+0.5*estimated_vol=306.64052520186686; 20bps+1.0*estimated_vol=405.44587601307126.",
    "First adaptive fair-price/volatility candidate: 437.5517751853003 on the full default native CLI batch. A 10-simulation CLI/harness cross-check matched exactly at 353.5154827738471.",
    "Adaptive rational quote curve with separate first-trade/subsequent-trade learning rates: 112 completed parameter trials, best exploratory mean 543.8022771545725 on 100 simulations, seeds 100000..100099. Selected frozen model: 537.1920597922142 on default 1000 and 532.3983716262778 on separate evaluation seeds 200000..200999. Ordinary CLI independently reproduced 537.1920597922142.",
    "Suppress first-trade learning when inferred terminal arbitrage profit is too small: 89 completed parameter trials, best exploratory mean 556.9543993216461 on the same 100-simulation exploratory block. Selected frozen candidate: 548.2206521880121 on default 1000; 542.1877714439241 on separate evaluation seeds 200000..200999.",
    "Bayesian arb-versus-retail likelihood filter (4 trials, original short-horizon volatility): exploratory means [-402.11066699562747, 37.31693308487318, 221.19734419783242, -392.78154067792747]; rejected for lagging price estimates.",
    "Bayesian filter with raw inferred-price innovations for volatility (4 trials): exploratory means [377.1706962166172, 334.0896891231701, 320.8895607643541, 320.09632192764803].",
    "Volatility-scaled virtual liquidity, exponent 0.5/1.0/-0.5/-1.0: exploratory means [540.7292738170509, 496.6510962482887, 534.8147232407083, 518.5886789945893] on 100 simulations, seeds 100000..100099.",
    "Longer-horizon volatility sampling: initial 100-simulation means [526.4522344090324, 519.3502052311354, 533.6739006238572, 425.9207360541221, 405.6824325851524] on seeds 100000..100099; 52 completed parameter trials, best exploratory mean 476.1506345419723 on seeds 300000..300099. The simple model scored 470.37241501400223 on that latter block; gains were marginal, so search stopped.",
    "Bayesian filter plus longer-horizon volatility (4 trials): exploratory means [419.7938308396557, 427.71311904966393, 419.0115960870919, 320.9193244728426] on 100 simulations, seeds 100000..100099.",
    "Supervised 144-bin fair-price learning-rate table, trained on 512 varied markets (seeds 10000000+i*104729), 3941918 trade observations: unblended full-default mean 525.5171211214914; independent 1000-simulation mean 521.0078059313702. Fair price was a training label only; final entry never reads fair price or a seed.",
    "First learned table, 14 base/volatility-spread recalibrations on 100 simulations, seeds 500000..500099: best exploratory mean 564.5128531977069.",
    "Second supervised pass, 512 new markets (seeds 90000000+i*104729), 4321626 observations, 14 spread recalibrations: best exploratory mean 566.9548881154743 on 100 simulations, seeds 500000..500099; selected full-default mean 560.8215446914693, below the chosen blend.",
    "Blend original estimator with first learned table, weights 0/0.25/0.5/0.75/1.0, 200 simulations x 10000 steps, seeds 500000..500199: [553.0830619689585, 572.594676706751, 584.4764074343759, 585.3816002225814, 547.8209391935633]. Weight 0.75 selected before full default/holdout tests.",
    "BPF validation passed; five 10000-step BPF JIT simulations and their native counterparts both averaged 331.4420473173447. This small workload is a parity check, not the reported best score.",
    "Full 1000-simulation BPF JIT attempt: timed out after 1860 seconds; no score returned. The reported best is the completed native CLI score. BPF compilation, validator parity and five full-length BPF simulations passed.",
    "Fresh final evaluation after freezing source: 594.4303245383276, standard error 14.111167364300353, 1000 simulations x 10000 steps, seeds 700000..700999. This block was excluded from training and parameter sweeps; the score did not trigger any source or parameter changes. Headline best_score keeps the standard default seed block.",
    "BEST: 75% learned-table blend, complete source embedded in entry. Default native CLI 1000-simulation mean 568.6003061725964 (standard error from original-runner harness 12.631273539471817); separate 1000-simulation evaluation mean 564.0112124228319 (standard error 12.923827910375916), seeds 200000..200999. Reported best_score=568.6003061725964; BPF validation passed. All score values are unrounded scorer outputs; exploratory batches are explicitly smaller and are not leaderboard claims."
  ],
  "width": "Many seats would help diverse algorithm research, but this scout does not justify sending all 100 here yet: the measured gap is 242.7911202610205 average-edge units, much larger than the difference between the independent 1000-simulation means. The explored simple families plateaued, while a learned-table blend added 31.4082463803822 units to the earlier simple model. Start a 12-seat pilot: 4 on price/state inference, 4 on quote curves and inventory, 2 on joint fee/learning objectives, 2 on blind evaluation and BPF correctness. Share a pinned offline toolchain/cache and common final evaluation blocks; give research groups separate training markets. Expand only when multiple independent full batches approach the live top-three threshold. This run cannot estimate how many seats would close the gap or guarantee top three.",
  "next": "1. Package the pinned native/SBF toolchains, Zig linker and crate cache as ordinary offline files for reuse, and measure throughput with fixed CPU allocation; setup and concurrent work materially affected timings here. Use native full batches for research and shared BPF parity checks for finalists; the full BPF-1000 attempt exceeded 31 minutes here. 2. Run the 12-seat research split above, including end-to-end edge objectives: the unblended learned filter hurt edge, whereas joint blending improved it. Keep all policies seed-agnostic and reserve untouched evaluation markets. 3. Freeze finalists, compare several 1000-simulation batches, repeat BPF shape/parity checks, refresh the public third-place score, and give the operator a source/hash/score bundle for any later manual entry. Do not submit from tasks."
}