nx_domain_golive.nx source

1// nx_domain_golive.nx -- Orchestrate domain purchase and live activation on the sovereign edge through predefined, idempotent steps. 2import "nx_gate_gn.nx" 3import "nx_gate_base.nx" 4// nx_domain_golive.nx -- the DOMAIN GO-LIVE ORCHESTRATION state machine: buy a domain on Porkbun 5// and take it live on the sovereign edge, as ORDERED, PRECONDITIONED, IDEMPOTENT steps. The steps 6// are DATA (rule 11); the machine refuses skipping, refuses the SPEND step without BOTH a green 7// dry-run token AND the operator confirm, refuses edge mutation without the operator flag, and a 8// completed spend step can never run twice (no double-purchase by construction). 9// step 0 CHECK -- /domain/checkDomain: avail + quote (read-only) 10// step 1 DRYRUN -- /domain/create dryRun:true wouldSucceed (read-only, no charge) 11// step 2 REGISTER -- /domain/create (SPEND: needs dryrun-ok + confirm + quote<=cap) 12// step 3 DNS -- A records @ + www -> WAN (nx_porkbun_set_a / nx_porkbun_publish_a) 13// step 4 CERT -- ssl/retrieve bundle (0600) or nx_acme_issue DNS-01 14// step 5 EDGE -- SNI route + sites namespace on the NAS (OPERATOR-GATED: contended files) 15// step 6 VERIFY -- live 200 over sovereign TLS from the WAN side 16// Executors: nx_porkbun_domain (0-2,4), nx_acme_porkbun/nx_porkbun_publish_a (3), nx_acme_issue (4), 17// the mgmt/never-brick plane (5), nx_https/acme GET (6). This gate proves the DRIVER's laws. 18// license_tier: ORIGINAL expect_exit: 0 19import "nx_syscalls.nx" 20const GL_MAGIC_1108: i64 = 1108 21const GL_MAGIC_1500: i64 = 1500 22const GL_MAGIC_1600: i64 = 1600 23 24const GL_NSTEPS: i64 = 7 25const GL_CHECK: i64 = 0 26const GL_DRYRUN: i64 = 1 27const GL_REGISTER: i64 = 2 28const GL_DNS: i64 = 3 29const GL_CERT: i64 = 4 30const GL_EDGE: i64 = 5 31const GL_VERIFY: i64 = 6 32 33func grow(name: *u8, ok: i64) -> i64 { if ok==1 { gw(" PASS " as *u8) } else { gw(" FAIL " as *u8) } gw(name); gw(" 34" as *u8); return ok } 35func gcheck(pass: i64, label: *u8, fails: *i64) -> i64 { 36 gw(" " as *u8); gw(label); gw(": " as *u8) 37 if pass==1 { gw("PASS\n" as *u8) } else { gw("FAIL\n" as *u8); fails[0]=fails[0]+1 } 38 return 0 39} 40 41// st: [0]=next-step [1]=dryrun_ok [2]=spend_done [3..9]=step done flags base 42// flags: [0]=operator_confirm_spend [1]=operator_edge_ack [2]=quote_cents [3]=cap_cents 43// advance codes: 1 ok; 2 already-done (idempotent no-op); -1 out-of-order; -2 spend w/o dryrun-ok; 44// -3 spend w/o operator confirm; -4 quote>cap; -5 double-spend refused; -6 edge w/o operator ack. 45func gl_advance(st: *i64, flags: *i64, step: i64, result_ok: i64) -> i64 { 46 let donebase: i64 = 3 47 if st[donebase+step]==1 { 48 if step==GL_REGISTER { return 0-5 } 49 return 2 50 } 51 if step != st[0] { return 0-1 } 52 if step==GL_REGISTER { 53 if st[1]!=1 { return 0-2 } 54 if flags[0]!=1 { return 0-3 } 55 if flags[2]<=0 { return 0-4 } 56 if flags[3]<=0 { return 0-4 } 57 if flags[2]>flags[3] { return 0-4 } 58 } 59 if step==GL_EDGE { 60 if flags[1]!=1 { return 0-6 } 61 } 62 if result_ok!=1 { return 0 } 63 st[donebase+step]=1 64 st[0]=step+1 65 if step==GL_DRYRUN { st[1]=1 } 66 if step==GL_REGISTER { st[2]=1 } 67 return 1 68} 69 70func main() -> i64 { 71 let fails: *i64 = sys_mmap(16) as *i64 72 fails[0]=0 73 gw("=== nx_domain_golive -- purchase->live orchestration: ordered, spend-safe, idempotent ===\n" as *u8) 74 75 let st: *i64 = sys_mmap(16*8) as *i64 76 let flags: *i64 = sys_mmap(8*8) as *i64 77 var i: i64=0 78 while i<16 { st[i]=0; i=i+1 } 79 flags[0]=0; flags[1]=0; flags[2]=GL_MAGIC_1108; flags[3]=GL_MAGIC_1500 80 81 // T1: skipping ahead is refused (REGISTER before CHECK/DRYRUN -> out-of-order) 82 let s1: i64 = gl_advance(st, flags, GL_REGISTER, 1) 83 var t1: i64=0; if s1==(0-1) { t1=1 } 84 gcheck(t1, "T1 out-of-order step refused (no register before check/dryrun)" as *u8, fails) 85 86 // T2: CHECK then DRYRUN advance in order 87 let s2a: i64 = gl_advance(st, flags, GL_CHECK, 1) 88 let s2b: i64 = gl_advance(st, flags, GL_DRYRUN, 1) 89 var t2: i64=0 90 if s2a==1 { if s2b==1 { if st[0]==GL_REGISTER { if st[1]==1 { t2=1 } } } } 91 gcheck(t2, "T2 check -> dryrun advance in order; dryrun-ok token recorded" as *u8, fails) 92 93 // T3: REGISTER without operator confirm refused even after green dryrun 94 let s3: i64 = gl_advance(st, flags, GL_REGISTER, 1) 95 var t3: i64=0; if s3==(0-3) { t3=1 } 96 gcheck(t3, "T3 spend without operator confirm refused (dryrun alone is not consent)" as *u8, fails) 97 98 // T4: over-cap refused; at-cap passes the wall 99 flags[0]=1 100 flags[2]=GL_MAGIC_1600 101 let s4a: i64 = gl_advance(st, flags, GL_REGISTER, 1) 102 flags[2]=GL_MAGIC_1108 103 let s4b: i64 = gl_advance(st, flags, GL_REGISTER, 1) 104 var t4: i64=0 105 if s4a==(0-4) { if s4b==1 { if st[2]==1 { t4=1 } } } 106 gcheck(t4, "T4 over-cap spend refused; in-cap spend completes once" as *u8, fails) 107 108 // T5: DOUBLE-SPEND structurally refused (completed register can never run again) 109 let s5: i64 = gl_advance(st, flags, GL_REGISTER, 1) 110 var t5: i64=0; if s5==(0-5) { t5=1 } 111 gcheck(t5, "T5 double-purchase refused by construction (register is once-only)" as *u8, fails) 112 113 // T6: DNS + CERT advance; EDGE refuses without the operator ack (contended NAS files) 114 gl_advance(st, flags, GL_DNS, 1) 115 gl_advance(st, flags, GL_CERT, 1) 116 let s6a: i64 = gl_advance(st, flags, GL_EDGE, 1) 117 flags[1]=1 118 let s6b: i64 = gl_advance(st, flags, GL_EDGE, 1) 119 let s6c: i64 = gl_advance(st, flags, GL_VERIFY, 1) 120 var t6: i64=0 121 if s6a==(0-6) { if s6b==1 { if s6c==1 { if st[0]==GL_NSTEPS { t6=1 } } } } 122 gcheck(t6, "T6 dns->cert->edge(operator-gated)->verify complete the pipeline" as *u8, fails) 123 124 // T7: re-running a DONE non-spend step is an idempotent no-op (rule 10) 125 let s7: i64 = gl_advance(st, flags, GL_DNS, 1) 126 var t7: i64=0; if s7==2 { t7=1 } 127 gcheck(t7, "T7 completed non-spend step re-run = idempotent no-op" as *u8, fails) 128 129 // T8: a FAILED step result does not advance state (fail-closed progression) 130 let st2: *i64 = sys_mmap(16*8) as *i64 131 var k: i64=0 132 while k<16 { st2[k]=0; k=k+1 } 133 let s8: i64 = gl_advance(st2, flags, GL_CHECK, 0) 134 var t8: i64=0 135 if s8==0 { if st2[0]==GL_CHECK { t8=1 } } 136 gcheck(t8, "T8 failed step result does not advance (fail-closed progression)" as *u8, fails) 137 138 gw(" fails=" as *u8); gn(fails[0]); gw("\n" as *u8) 139 if fails[0]==0 { gw("VERDICT: GREEN (go-live driver: ordered, dryrun-then-confirm spend, once-only purchase, operator-gated edge)\n" as *u8); sys_exit(0) } 140 gw("VERDICT: RED\n" as *u8) 141 sys_exit(1) 142 return 1 143}