Foundation / checks (tsan) (push) Canceled after 0s
Foundation / postgres-tools (push) Canceled after 0s
Foundation / server-image (push) Canceled after 0s
Foundation / image (push) Canceled after 0s
Foundation / checks (client) (push) Canceled after 1m11s
Foundation / checks (checks) (push) Canceled after 1m13s
Foundation / checks (postgres) (push) Canceled after 1m8s
Foundation / checks (ecs) (push) Canceled after 1m13s
Foundation / checks (network) (push) Canceled after 1m14s
Foundation / checks (deploy) (push) Canceled after 1m18s
281 lines
15 KiB
PL/PgSQL
281 lines
15 KiB
PL/PgSQL
-- ADR-0168: raw-only bundle 12 / trace 4 and exact bundle 11 -> 12 upgrades.
|
|
-- Normalization below is parser-local. Stored evidence and retries retain real bytes.
|
|
ALTER FUNCTION evolution.parse_checkpoint_manifest(bytea) RENAME TO parse_checkpoint_manifest_v54;
|
|
REVOKE ALL ON FUNCTION evolution.parse_checkpoint_manifest_v54(bytea) FROM PUBLIC, :"runtime_role";
|
|
CREATE FUNCTION evolution.parse_checkpoint_manifest(m bytea)
|
|
RETURNS evolution.checkpoint_manifest LANGUAGE plpgsql IMMUTABLE
|
|
SET search_path=pg_catalog,pg_temp AS $$
|
|
DECLARE c evolution.checkpoint_manifest;
|
|
b11 constant bytea := '\x090000000700000002000000010000000100000004000000030000000200000001000000';
|
|
b12 constant bytea := '\x0a0000000800000002000000010000000100000004000000030000000200000001000000';
|
|
BEGIN
|
|
IF m IS NOT NULL AND octet_length(m)=360 AND evolution.manifest_uint(m,12,4)=4
|
|
AND evolution.manifest_uint(m,228,4)=0 AND evolution.manifest_uint(m,232,4)=4
|
|
AND evolution.manifest_uint(m,236,4)=1 AND substring(m FROM 161 FOR 36)=b12 THEN
|
|
c := evolution.parse_checkpoint_manifest_v54(overlay(m PLACING b11 FROM 161 FOR 36));
|
|
c.versions := b12;
|
|
RETURN c;
|
|
END IF;
|
|
RETURN evolution.parse_checkpoint_manifest_v54(m);
|
|
END $$;
|
|
REVOKE ALL ON FUNCTION evolution.parse_checkpoint_manifest(bytea) FROM PUBLIC;
|
|
|
|
ALTER FUNCTION evolution.cellular_births(bytea,bytea) RENAME TO cellular_births_v54;
|
|
REVOKE ALL ON FUNCTION evolution.cellular_births_v54(bytea,bytea) FROM PUBLIC, :"runtime_role";
|
|
CREATE FUNCTION evolution.cellular_births(t bytea,m bytea)
|
|
RETURNS TABLE(account_id uuid,request_id evolution.u64,generation evolution.u64,identity evolution.u64,born evolution.u64)
|
|
LANGUAGE plpgsql IMMUTABLE SET search_path=pg_catalog,pg_temp AS $$
|
|
DECLARE c evolution.checkpoint_manifest := evolution.parse_checkpoint_manifest(m);
|
|
b11 constant bytea := '\x090000000700000002000000010000000100000004000000030000000200000001000000';
|
|
b12 constant bytea := '\x0a0000000800000002000000010000000100000004000000030000000200000001000000';
|
|
BEGIN
|
|
IF c.versions=b12 THEN
|
|
IF t IS NULL OR octet_length(t)<>c.trace_bytes OR sha256(t)<>c.trace_sha256
|
|
OR evolution.manifest_uint(t,8,4)<>4 THEN
|
|
RAISE EXCEPTION 'invalid retained-plan trace binding' USING ERRCODE='22023';
|
|
END IF;
|
|
t := overlay(t PLACING '\x03000000'::bytea FROM 9 FOR 4);
|
|
m := overlay(m PLACING b11 FROM 161 FOR 36);
|
|
m := overlay(m PLACING sha256(t) FROM 289 FOR 32);
|
|
END IF;
|
|
RETURN QUERY SELECT * FROM evolution.cellular_births_v54(t,m);
|
|
END $$;
|
|
REVOKE ALL ON FUNCTION evolution.cellular_births(bytea,bytea) FROM PUBLIC;
|
|
|
|
ALTER TABLE evolution.cellular_mutation_action_publications
|
|
DROP CONSTRAINT cellular_mutation_action_publications_result_check;
|
|
ALTER TABLE evolution.cellular_mutation_action_publications
|
|
ADD CONSTRAINT cellular_mutation_action_publications_result_check CHECK(result BETWEEN 0 AND 4);
|
|
|
|
CREATE OR REPLACE FUNCTION evolution.cellular_mutation_selections(p_trace bytea, p_manifest bytea)
|
|
RETURNS TABLE(tick evolution.u64, life_id evolution.u64, event_index evolution.u64,
|
|
offer_tick evolution.u64, successor_identity evolution.u64, operator_id integer)
|
|
LANGUAGE plpgsql IMMUTABLE SECURITY INVOKER SET search_path = pg_catalog, pg_temp AS $$
|
|
DECLARE
|
|
c evolution.checkpoint_manifest := evolution.parse_checkpoint_manifest(p_manifest);
|
|
ticks integer;
|
|
off integer := 112;
|
|
intent_count integer;
|
|
birth_count integer;
|
|
mutation_count integer;
|
|
previous_life numeric;
|
|
BEGIN
|
|
PERFORM * FROM evolution.cellular_births(p_trace, p_manifest); -- Binding and structure.
|
|
IF evolution.manifest_uint(p_trace, 8, 4) NOT IN (3,4) THEN
|
|
RETURN; -- Format 2 carries no selections.
|
|
END IF;
|
|
ticks := (c.end_tick - c.begin_tick)::integer;
|
|
FOR tick_index IN 0 .. ticks - 1 LOOP
|
|
intent_count := evolution.manifest_uint(p_trace, off, 4)::integer;
|
|
birth_count := evolution.manifest_uint(p_trace, off + 4, 4)::integer;
|
|
mutation_count := evolution.manifest_uint(p_trace, off + 8, 4)::integer;
|
|
off := off + 16 + intent_count * 24 + birth_count * 40;
|
|
previous_life := 0;
|
|
FOR mutation_index IN 0 .. mutation_count - 1 LOOP
|
|
tick := c.begin_tick + tick_index + 1;
|
|
life_id := evolution.manifest_uint(p_trace, off, 8);
|
|
event_index := evolution.manifest_uint(p_trace, off + 8, 8);
|
|
offer_tick := evolution.manifest_uint(p_trace, off + 16, 8);
|
|
successor_identity := evolution.manifest_uint(p_trace, off + 24, 8);
|
|
operator_id := evolution.manifest_uint(p_trace, off + 32, 2)::integer;
|
|
IF life_id = 0 OR life_id <= previous_life OR event_index = 0 OR offer_tick = 0
|
|
OR offer_tick >= tick OR successor_identity = 0
|
|
OR substring(p_trace FROM off + 35 FOR 6) <> '\x000000000000' THEN
|
|
RAISE EXCEPTION 'invalid cellular mutation selection' USING ERRCODE = '22023';
|
|
END IF;
|
|
previous_life := life_id;
|
|
off := off + 40;
|
|
RETURN NEXT;
|
|
END LOOP;
|
|
END LOOP;
|
|
END $$;
|
|
|
|
-- Results 0 applied, 1 life died, 2 insufficient funding, 3 declined.
|
|
CREATE OR REPLACE FUNCTION evolution.check_cellular_mutation_block(p_manifest bytea, p_trace bytea,
|
|
p_mutations bytea, p_results bytea)
|
|
RETURNS integer LANGUAGE plpgsql STABLE SECURITY INVOKER
|
|
SET search_path = pg_catalog, pg_temp AS $$
|
|
DECLARE
|
|
c evolution.checkpoint_manifest := evolution.parse_checkpoint_manifest(p_manifest);
|
|
n integer;
|
|
account uuid;
|
|
account_bytes bytea;
|
|
action numeric;
|
|
tick numeric;
|
|
input bytea;
|
|
previous_tick numeric := -1;
|
|
previous_account bytea := ''::bytea;
|
|
previous_action numeric := -1;
|
|
r evolution.cellular_mutation_reservations%ROWTYPE;
|
|
BEGIN
|
|
IF p_mutations IS NULL OR p_results IS NULL OR octet_length(p_mutations) = 0
|
|
OR octet_length(p_mutations) % 64 <> 0 OR octet_length(p_mutations) / 64 > 1024
|
|
OR octet_length(p_results) <> octet_length(p_mutations) / 64 THEN
|
|
RAISE EXCEPTION 'invalid cellular mutation block' USING ERRCODE = '22023';
|
|
END IF;
|
|
n := octet_length(p_mutations) / 64;
|
|
IF (SELECT count(*) FROM evolution.cellular_mutation_selections(p_trace, p_manifest)) <> n THEN
|
|
RAISE EXCEPTION 'cellular mutation block does not cover the trace' USING ERRCODE = '22023';
|
|
END IF;
|
|
FOR i IN 0 .. n - 1 LOOP
|
|
account_bytes := substring(p_mutations FROM 64 * i + 1 FOR 16);
|
|
account := encode(account_bytes, 'hex')::uuid;
|
|
action := evolution.manifest_uint(p_mutations, 64 * i + 16, 8);
|
|
input := substring(p_mutations FROM 64 * i + 25 FOR 34);
|
|
tick := evolution.manifest_uint(input, 0, 8);
|
|
IF account = '00000000-0000-0000-0000-000000000000' OR action = 0
|
|
OR NOT evolution.valid_cellular_mutation_input(input)
|
|
OR substring(p_mutations FROM 64 * i + 59 FOR 6) <> '\x000000000000'
|
|
OR (c.versions='\x0a0000000800000002000000010000000100000004000000030000000200000001000000'::bytea
|
|
AND (get_byte(p_results,i) NOT IN (1,3,4)
|
|
OR (evolution.manifest_uint(input,32,2)=0 AND get_byte(p_results,i) NOT IN (1,3))
|
|
OR (evolution.manifest_uint(input,32,2)<>0 AND get_byte(p_results,i) NOT IN (1,4))))
|
|
OR (c.versions<>'\x0a0000000800000002000000010000000100000004000000030000000200000001000000'::bytea
|
|
AND get_byte(p_results,i)>3)
|
|
OR tick <= c.begin_tick OR tick > c.end_tick
|
|
OR (tick, account_bytes, action) <= (previous_tick, previous_account, previous_action) THEN
|
|
RAISE EXCEPTION 'invalid cellular mutation record' USING ERRCODE = '22023';
|
|
END IF;
|
|
previous_tick := tick;
|
|
previous_account := account_bytes;
|
|
previous_action := action;
|
|
SELECT * INTO r FROM evolution.cellular_mutation_reservations x
|
|
WHERE x.world_id = c.world_id AND x.account_id = account AND x.action_id = action;
|
|
IF NOT FOUND OR r.region_id <> c.region_id OR r.input_bytes <> input
|
|
OR r.target_tick <> evolution.manifest_uint(input, 0, 8) THEN
|
|
RAISE EXCEPTION 'cellular mutation reservation conflicts' USING ERRCODE = 'EVL16';
|
|
END IF;
|
|
IF NOT EXISTS (SELECT 1 FROM evolution.cellular_mutation_selections(p_trace, p_manifest) s
|
|
WHERE s.tick = r.target_tick AND s.successor_identity = r.successor_identity
|
|
AND s.life_id = evolution.manifest_uint(input, 8, 8)
|
|
AND s.event_index = evolution.manifest_uint(input, 16, 8)
|
|
AND s.offer_tick = evolution.manifest_uint(input, 24, 8)
|
|
AND s.operator_id = evolution.manifest_uint(input, 32, 2)) THEN
|
|
RAISE EXCEPTION 'cellular mutation differs from its trace' USING ERRCODE = '22023';
|
|
END IF;
|
|
END LOOP;
|
|
RETURN n;
|
|
END $$;
|
|
|
|
|
|
ALTER FUNCTION evolution.publish_cellular_profile_migration(bytea) RENAME TO publish_cellular_profile_migration_v54;
|
|
REVOKE ALL ON FUNCTION evolution.publish_cellular_profile_migration_v54(bytea) FROM PUBLIC, :"runtime_role";
|
|
CREATE OR REPLACE FUNCTION evolution.publish_cellular_profile_migration(p_manifest bytea)
|
|
RETURNS TABLE(region_frame evolution.u64, head_sequence evolution.u64, head_commit uuid,
|
|
head_digest text, head_tick evolution.u64)
|
|
LANGUAGE plpgsql SECURITY DEFINER SET search_path = pg_catalog, pg_temp AS $$
|
|
DECLARE
|
|
c evolution.checkpoint_manifest := evolution.parse_checkpoint_manifest(p_manifest);
|
|
s evolution.checkpoint_manifest;
|
|
h evolution.region_heads%ROWTYPE;
|
|
p evolution.region_commits%ROWTYPE;
|
|
old evolution.region_commits%ROWTYPE;
|
|
frame evolution.u64;
|
|
d bytea := sha256(p_manifest);
|
|
source_bundle constant bytea := '\x090000000700000002000000010000000100000004000000030000000200000001000000';
|
|
target_bundle constant bytea := '\x0a0000000800000002000000010000000100000004000000030000000200000001000000';
|
|
zero32 constant bytea := decode(repeat('00', 32), 'hex');
|
|
BEGIN
|
|
IF c.versions <> target_bundle THEN
|
|
RETURN QUERY SELECT * FROM evolution.publish_cellular_profile_migration_v54(p_manifest);
|
|
RETURN;
|
|
END IF;
|
|
IF c.profile <> 4 OR c.commit_sequence = 0 OR c.begin_tick <> c.end_tick
|
|
OR c.end_tick = 0 OR c.versions <> target_bundle
|
|
OR evolution.manifest_uint(p_manifest, 228, 4) <> 0
|
|
OR evolution.manifest_uint(p_manifest, 232, 4) <> (CASE c.profile WHEN 4 THEN 4 ELSE 5 END)
|
|
OR evolution.manifest_uint(p_manifest, 236, 4) <> 1
|
|
OR c.trace_bytes <> 0 OR c.trace_sha256 <> zero32
|
|
OR c.decision_count <> 0 OR c.decisions_sha256 <> zero32 THEN
|
|
RAISE EXCEPTION 'invalid retained-plan profile migration' USING ERRCODE = '22023';
|
|
END IF;
|
|
PERFORM evolution.check_region_lease(c.world_id, c.region_id, c.holder, c.epoch);
|
|
SELECT * INTO old FROM evolution.region_commits r WHERE r.commit_id = c.commit_id;
|
|
IF FOUND THEN
|
|
IF old.manifest <> p_manifest THEN
|
|
RAISE EXCEPTION 'cellular profile migration identity reused' USING ERRCODE = 'EVL07';
|
|
END IF;
|
|
SELECT * INTO p FROM evolution.region_commits r
|
|
WHERE r.world_id = old.world_id AND r.region_id = old.region_id
|
|
AND r.commit_sequence = old.commit_sequence - 1;
|
|
IF NOT FOUND OR NOT EXISTS (
|
|
SELECT 1 FROM evolution.cellular_profile_migrations m
|
|
WHERE m.target_commit = c.commit_id AND m.world_id = c.world_id
|
|
AND m.region_id = c.region_id AND m.source_sequence = p.commit_sequence
|
|
AND m.source_commit = p.commit_id AND m.source_manifest_sha256 = p.commit_digest
|
|
AND m.source_payload_sha256 = p.payload_sha256 AND m.source_versions = p.versions
|
|
AND m.target_sequence = old.commit_sequence AND m.target_manifest_sha256 = d
|
|
AND m.target_payload_sha256 = old.payload_sha256 AND m.target_versions = old.versions
|
|
AND m.source_commit = c.predecessor_commit
|
|
AND m.source_manifest_sha256 = c.predecessor_digest) THEN
|
|
RAISE EXCEPTION 'cellular profile migration identity reused' USING ERRCODE = 'EVL07';
|
|
END IF;
|
|
SELECT l.frame_id INTO frame FROM evolution.region_leases l
|
|
WHERE l.world_id = c.world_id AND l.region_id = c.region_id;
|
|
RETURN QUERY SELECT frame, old.commit_sequence, old.commit_id,
|
|
encode(old.commit_digest, 'hex'), old.end_tick;
|
|
RETURN;
|
|
END IF;
|
|
IF EXISTS (SELECT 1 FROM evolution.population_interval_pending x
|
|
WHERE x.world_id = c.world_id AND x.region_id = c.region_id) THEN
|
|
RAISE EXCEPTION 'retained-plan upgrade waits for interval' USING ERRCODE = 'EVL18';
|
|
END IF;
|
|
IF EXISTS (SELECT 1 FROM evolution.cellular_mutation_reservations x
|
|
WHERE x.world_id=c.world_id AND x.region_id=c.region_id AND NOT EXISTS
|
|
(SELECT 1 FROM evolution.cellular_mutation_action_publications a
|
|
WHERE a.world_id=x.world_id AND a.account_id=x.account_id AND a.action_id=x.action_id)) THEN
|
|
RAISE EXCEPTION 'retained-plan upgrade waits for mutation choice' USING ERRCODE='EVL18';
|
|
END IF;
|
|
SELECT * INTO h FROM evolution.region_heads r
|
|
WHERE r.world_id = c.world_id AND r.region_id = c.region_id FOR UPDATE;
|
|
IF NOT FOUND OR h.commit_sequence = 18446744073709551615
|
|
OR c.commit_sequence <> h.commit_sequence + 1 OR c.predecessor_commit <> h.commit_id
|
|
OR c.predecessor_digest <> h.digest OR c.begin_tick <> h.end_tick THEN
|
|
RAISE EXCEPTION 'region head moved' USING ERRCODE = 'EVL03';
|
|
END IF;
|
|
SELECT * INTO p FROM evolution.region_commits r
|
|
WHERE r.world_id = c.world_id AND r.region_id = c.region_id
|
|
AND r.commit_sequence = h.commit_sequence;
|
|
IF NOT FOUND THEN
|
|
RAISE EXCEPTION 'missing migration predecessor' USING ERRCODE = 'XX000';
|
|
END IF;
|
|
s := evolution.parse_checkpoint_manifest(p.manifest);
|
|
IF s.profile <> c.profile OR s.versions <> source_bundle OR p.versions <> source_bundle
|
|
OR c.frame_id <> s.frame_id OR c.tick_microseconds <> s.tick_microseconds
|
|
OR s.commit_id <> c.predecessor_commit OR s.end_tick <> c.end_tick
|
|
OR evolution.manifest_uint(p.manifest, 232, 4) <> (CASE c.profile WHEN 4 THEN 4 ELSE 5 END)
|
|
OR NOT EXISTS (SELECT 1 FROM evolution.retained_builds b
|
|
WHERE b.build_identity = c.build_identity) THEN
|
|
RAISE EXCEPTION 'unsupported retained-plan profile migration' USING ERRCODE = 'EVL06';
|
|
END IF;
|
|
SELECT l.frame_id INTO frame FROM evolution.region_leases l
|
|
WHERE l.world_id = c.world_id AND l.region_id = c.region_id;
|
|
IF c.frame_id <> frame THEN
|
|
RAISE EXCEPTION 'foreign frame' USING ERRCODE = '22023';
|
|
END IF;
|
|
INSERT INTO evolution.cellular_profile_migrations(target_commit, world_id, region_id,
|
|
source_sequence, source_commit, source_manifest_sha256, source_payload_sha256,
|
|
source_versions, target_sequence, target_manifest_sha256, target_payload_sha256,
|
|
target_versions)
|
|
VALUES (c.commit_id, c.world_id, c.region_id, p.commit_sequence, p.commit_id,
|
|
p.commit_digest, p.payload_sha256, p.versions, c.commit_sequence, d,
|
|
c.payload_sha256, c.versions);
|
|
INSERT INTO evolution.region_commits(world_id, region_id, commit_sequence, commit_id,
|
|
commit_digest, manifest, begin_tick, end_tick, published_epoch, tick_microseconds,
|
|
versions, build_identity, payload_bytes, payload_sha256)
|
|
VALUES (c.world_id, c.region_id, c.commit_sequence, c.commit_id, d, p_manifest,
|
|
c.begin_tick, c.end_tick, c.epoch, c.tick_microseconds, c.versions,
|
|
c.build_identity, c.payload_bytes, c.payload_sha256);
|
|
UPDATE evolution.region_heads r
|
|
SET commit_sequence = c.commit_sequence, commit_id = c.commit_id, digest = d,
|
|
end_tick = c.end_tick, published_epoch = c.epoch
|
|
WHERE r.world_id = c.world_id AND r.region_id = c.region_id;
|
|
RETURN QUERY SELECT frame, c.commit_sequence, c.commit_id, encode(d, 'hex'), c.end_tick;
|
|
END $$;
|
|
REVOKE ALL ON FUNCTION evolution.publish_cellular_profile_migration(bytea) FROM PUBLIC;
|
|
GRANT EXECUTE ON FUNCTION evolution.publish_cellular_profile_migration(bytea) TO :"runtime_role";
|
|
|
|
|
|
|
|
INSERT INTO evolution.schema_migrations(version,sha256) VALUES(55,:'migration_sha_55');
|