Repository navigation
Description
Owner: @Lexirieru (contract) · Relay side: @Lin1er · Branch: fix/claim-owner · Labels: bug, deliverable-1, gate · Affects: #77, #94, and every real proof
TL;DR
The production contract cannot accept any real proof, AdSense or AdMob. verify_claim rebuilds the attestor's owner as the borrower's G… address, lowercased (sc/advance/src/lib.rs:577-580). A real proof from Reclaim's production attestor carries a different owner: the Reclaim app id the relay proves with (RECLAIM_APP_ID, 0x6415200c713135e77157e1536d488df4f2bb7d04). The digest therefore differs, the signature recovers to some other address, and Reclaim's verifier refuses it. The caller gets VerifierRejected.
Nothing caught this, because every proof the contract has verified so far was synthetic:
tools/rehearsal.pyandtools/make_claim_fixture.pysign withowner = borrower. The 7/7 GREEN rehearsal and the fixture tests prove the contract agrees with itself.tools/fixtures/real-reclaim-proof.jsonis real, but it proves the digest chain with that proof's ownowner, not the contract's rebuild.- No real AdSense proof has ever existed (Find an approved (READY) AdSense account for the gate and the demo #77).
Proven, not inferred
The first real Forepay claim was made on 2026-10-26 with prove:admob (#95, #100). It is signed by the production attestor and passed the audit:
claimData.owner 0x6415200c713135e77157e1536d488df4f2bb7d04 (= RECLAIM_APP_ID)
contextAddress GA2CD6PMHMBTCFAQDO3R22BSZN5ZSVTAKVNOKXL2SONZBLGRAYIOWWH2
digest with owner as signed → recovers to 0x244897572368eadf65bfbc5aec98d8e5443a9072 (the attestor)
digest with owner as the contract rebuilds it → recovers to 0x97268015c28bc96356a1abf80840d2495d467896 (nobody)
Same identifier, timestamp, epoch and signature. Only owner differs. The real attestor sets owner to the requesting app's address, which zkFetch takes from RECLAIM_APP_ID. It is not the context address.
Why the binding is still safe after the fix
The borrower is bound by context.contextAddress, which is inside the identifier. That does not change. owner never carried the binding; the comment at lib.rs:577 says it did, and that is the mistake. So fixing owner takes nothing away from #17/#18.
Proposed fix (contract)
Pin the owner, as an admin-set value, beside the template. Add DataKey::ClaimOwner (append-only), set by the admin to 0x6415…7d04, and rebuild the digest with it instead of the borrower.
- It needs no interface change: the front end and
request_advance's arguments stay as they are. - It also refuses claims made through any other Reclaim app. Without the pin, anyone could prove through their own app, and nothing else would stop them.
- Alternative: take
owneras an argument. That needs an interface change on the front end, and it accepts any app. Not recommended.
Tests: replace the synthetic owner = borrower in make_claim_fixture.py and rehearsal.py with a pinned app address. Then add one test that fails with the old rebuild: a claim whose owner is the app, verified with owner = borrower, gives VerifierRejected.
Timing. It has to go through propose_upgrade and the 24 h timelock, so it should ride in the same upgrade as #94, or go first on its own if #94 is not approved. Either way, it is what stands between any real account and a real advance before 2026-10-30. The demo's option 3 (rehearsal contract, test witness) is unaffected.
Relay side (@Lin1er)
- The audit checks
owneris the configuredRECLAIM_APP_ID, so a mismatch is caught before the front end submits. docs/interface.md§2 and thelib.rscomment get corrected.
Working agreement
- One issue, one owner. 2. Branch per issue, named above, not the GitHub-suggested one. 3. MCP Stellar Raven for any Stellar/Soroban fact that gets written down. 4. Merge through PR review by Axel (PM); no self-merge. If an ACC has not arrived within two days on something already verified, merge and say so in the PR. 5. Deploys need evidence: contract address or tx hash on stellar.expert, recorded in
docs/deployments.md. 6. Secrets live in.env, gitignored,chmod 600: never printed, never committed, never pasted into an issue or PR. Only publicG…andC…addresses appear anywhere. 7. Issues, commits and PRs in English.
Activity
fix(#102): the relay's audit checks owner is its own Reclaim app
Lin1er commentedon Oct 26, 2026
Fix in draft as #103, for @Lexirieru's review:
ClaimOwner(admin only, lowercase0x…). If nothing is pinned it falls back to the borrower, so the rehearsal keeps working. The fixture is signed a second time with the app as owner, and six tests cover it, including the bug itself kept as a test.owneragainstRECLAIM_APP_ID.Deploying it means
propose_upgrade, then 24 h, thenexecute_upgradeandset_claim_owner 0x6415200c713135e77157e1536d488df4f2bb7d04. On its own it unblocks real AdSense proofs. It only unblocks AdMob together with #94.fix(#102): re-record the linux wasm hash for the claim-owner contract
docs(#81): borrower authorisation executed, three days late
fix(#102): verify the attestor's owner against a pinned app id, not t…
feat(#94): AdMob as a second revenue source, and refuse an unpinned o…
Lexirieru commentedon Oct 29, 2026
Fix merged: #103 →
f3cdb18. @Lin1er thank you for this one — it is the find of the project so far.Staying open, because the bug is still live on chain. Both deployed contracts run
481e7f16…(v0.4.0, #81), which still rebuilds the owner from the borrower. Until the nextexecute_upgrade, neither can verify a real proof. The code being right inmainis not the thing this issue is about.It closes when all of this is done and recorded in
docs/deployments.md:propose_upgradewith the wasm carrying fix(#102): verify the attestor's owner against a pinned app id, not the borrower #103 + AdMob (#90): contract, a revenue source in the template, the nullifier and sizing #94 — one timelock for both, because Security: request_advance and verify_and_reserve take no borrower authorisation #81 used up the slack for twoexecute_upgradeon both contractsset_claim_owner 0x6415200c713135e77157e1536d488df4f2bb7d04Blocked on #106 (#94's contract work), which is in review.
The part I want kept after this closes
The reason nothing caught it is worth more than the fix.
rehearsal.pyandmake_claim_fixture.pyboth signed withowner = borrower, so every green run proved the contract agreed with itself. The 7/7 GREEN I reported on 2026-10-25, and again on 2026-10-29 after #81, were both that. A harness that produces exactly what the code expects cannot fail in the one way that matters.Same shape as #76: the part of our model that describes someone else's system was a guess until a real artifact arrived, and the fixture made the guess look verified.
#106 does something about the class rather than the instance. Taking away the owner fallback means a
G…address cannot be pinned at all —set_claim_ownertakes0xplus 40 hex digits — so the pre-#102 owner shape can no longer enter the harness by any route. Every test now runs through an app-signed claim. That is the lesson turned into something the compiler enforces, which is the only form of it that survives.test(#95): an AdMob proof is held to the relay's own claim owner too (#…
feat(#94): AdMob as a second revenue source, and refuse an unpinned c…
2 remaining items
feat(#95): an AdMob provider beside AdSense, selected by source on PO…
docs(#102,#94): v0.5.0 uploaded and proposed on both contracts
Lexirieru commentedon Oct 30, 2026
Proposed on both contracts. The clock is running.
stellar contract uploadeb636b27…18ea7cpropose_upgradeproductionCCQFL2Q6…I2HSe64318b0…df7366propose_upgradedevCD25Q4TD…HQN4b7e04e52…97eb66Wasm
ff6a16e988d8c31f27695efff60172764eefae9b19e2b95914c010c509e4f22e, read back from both contracts rather than taken from the submit output:Both were
nullimmediately before, so nothing was half-proposed, and the delay is exactly 86,400 seconds.The hash came from the release, and the procedure was proven before it was trusted
docs/deployments.mdcarries a warning from #15 — deploy the wasm from the release, not a local build — and one source tree gives three different hashes here:ff6a16e9…e4f22e← on chainf4fd10d6…a5a360c5c70c9…e1acddSo before uploading anything I re-downloaded v0.4.0's artifact and hashed it:
481e7f163ba3867b0e9bf48a36a983650a28a216f45c314fb21c94e9c4186696, byte for byte the wasm live on both contracts today. That is what makes "the artifact's sha256 is the on-chain hash" a measurement rather than an assumption.I also re-measured and corrected the macOS reference row, which still held a value from before #103 and #106 (
ee05add). A row nothing checks still gets read.execute_upgradeis not before 2026-10-31 13:49:10 UTCI will post here before running it. #81 sat executable and unexecuted for three days; that will not be repeated, and the cost of that delay is why #102 and #94 have to share this one upgrade instead of going separately.
@AncungAulia, step 3 is the one that needs you live
Right after
execute_upgrade:NEXT_PUBLIC_CONTRACT_TAKES_SOURCE=1onforepay-vue5, then rebuild. Between my call and your build finishing,app.forepay.xyzcannot take any advance, AdSense included — the deployed bundle sends nine arguments to a ten-argumentrequest_advance. No funds move and no proof is spent. Please name an hour tomorrow and I will execute then.One fee I still cannot measure, and will not guess
set_claim_templateon #76 wanted 21,370 XLM — rent on bytes × ledgers, not computation — and two templates have to be pinned this time from a balance of 29,433 XLM. The new two-argument signature does not exist on the deployed wasm yet, so this cannot be simulated until afterexecute_upgrade. I will read the fee at simulation on each call and post it before submitting. If it is anywhere near #76's figure, that is a decision for @Lexirieru, not a thing to discover by sending the transaction.Lexirieru commentedon Oct 30, 2026
Correcting the step 5 that @Lin1er and I both wrote
Both of us listed tomorrow's work as
set_claim_templatefor AdSense (#61) and AdMob (#96). The AdSense half cannot be run, and it is not a matter of finding the bytes — there are none to find.The only
READYAdSense account the team has access to is the one outside the team (#93), and its Jul–Sep 2026 earnings are zero. @Lin1er recorded that on #77 on 2026-10-26:A zero window does not produce a weak proof. It produces no proof at all —
be/src/adsense/account.tsstops before the attestor is ever called:So there is no attestor-signed
parametersstring for an AdSense claim, which is exactly whatpin_template.pysplits. #61 has nothing to pin, andset_claim_template --source AdSenseis not a command anyone can run today.What tomorrow actually is
execute_upgradeon bothset_claim_owner 0x6415200c713135e77157e1536d488df4f2bb7d04set_claim_template --source AdMob0x2448…9072,provider_hash 0x5d9a2fc4…8006set_claim_template --source AdSenseAdvanceOne template, not two. That halves the fee exposure I flagged, which matters: #76's
set_claim_templatewanted 21,370 XLM in rent. @Lexirieru has topped the deployer up to 30,433.56 XLM. I will still read the fee at simulation and post it before submitting — one template fitting is likely, not proven.This also means #94's AdSense fallback does the right thing by accident:
template_offalls back to the pre-#94 singleton key for AdSense only, and production's singleton isnull, so an AdSense proof getsTemplateNotSetrather than being checked against AdMob's shape. It fails closed, loudly, with the correct reason.The consequence for #5, which is the part worth arguing about
#5 is the feasibility gate: "one real AdSense revenue proof verified on testnet". That gate cannot be closed by AdMob, and it cannot be closed by the account we have. It needs an AdSense account with non-zero Jul–Sep 2026 revenue, and #77 — the issue that asks for exactly that — has been open since 2026-10-20 with no assignee.
Everything else is built and waiting on it: the provider (#74), the relay (#73), the front end (#75), the tool (#83, #101), and after tomorrow the contract. Nine days to 2026-11-08.
What AdMob does give us is stronger than a workaround, and worth saying plainly: the single part of this pipeline that was ever simulated — a production attestor signing a real creator's real revenue — now has a real signature behind it. The advance on chain will be real too. It is the source that differs from the SOW's wording, not the proof.
@Lexirieru, #77 needs an owner more than it needs anything technical from me.
Lexirieru commentedon Oct 30, 2026
The premise test, pinned before the upgrade rather than after
I promised to "read back an
Advancewritten by v0.4.0" as proof that#[contracttype]enum storage keys encode by name and not by position, so a newDataKeyvariant cannot shift an existing one.There is no such
Advanceto read. The 2026-10-29 rehearsal repaid its advance in full, which removes the entry, and each run uses a freshpub_id, so nothing is left:Production has never paid one at all, because
claim_template()isnullthere.The better test was available all along
DataKey::ParamsTemplateandDataKey::ProviderHashon the dev contract were written by v0.4.0 and are still there. #94 addsParamsTemplateFor(Source)andProviderHashFor(Source)beside them, andtemplate_offalls back to the old singleton keys for AdSense. So:That is a sharper test than the
Advanceone, because it exercises the fallback path and the key encoding in the same read, and it fails loudly rather than returning a plausible-looking default.Recorded now, from chain
What must and must not change tomorrow
execute_upgradeadmin,liquidity,sizingon bothclaim_template(),provider_hash()on devclaim_template()on productionnull, until AdMob is pinned underParamsTemplateFor(AdMob)claim_template_for(AdSense)on devclaim_template_for(AdMob)on bothTemplateNotSetuntil pinnedDeployer is at 30,433.56 XLM after @Lexirieru topped it up by 1,000. Still testnet only — the same
G…returns 404 on mainnet Horizon, which I checked before giving the address out.Lexirieru commentedon Oct 30, 2026
Dev first, then production — not "both" as I wrote earlier.
Both contracts carry the same proposal, ten seconds apart, and I have been writing the step as
execute_upgradeon both. That throws away the one piece of free risk reduction available here.CD25Q4TD…HQN4holds 2 USDC and the AdSense template.CCQFL2Q6…I2HSholds 105 USDC and is whatapp.forepay.xyzpoints at. They run identical wasm and will run identical wasm after. So tomorrow:execute_upgradeon dev only.claim_template()andprovider_hash()back from dev and require byte-equality with the baseline pinned above. That is the premise test, and dev is the only contract that can run it.admin,liquidity,sizingback from dev; require unchanged.execute_upgradeon production.If the enum-key premise is wrong — the thing #63 established and #94 rests on — it shows up on the contract holding 2 USDC, before the one holding 105 and before @AncungAulia starts a rebuild that cannot be undone quickly. The timelock on production does not expire; being ten minutes later costs nothing.
The cost if I am wrong and do them together: a production contract whose template reads
null, a front end rebuilt for a contract signature that half-works, andrenounce_upgradeabilitynot yet called so recovery means another 24-hour timelock. That is a day we do not have on 2026-10-31.@AncungAulia — this means your rebuild window starts after step 4, not step 1. I will post here between the two, so you will see dev go through before I touch production. Still 2026-10-31 from 20:50 WIB as @Lin1er set it; expect my post a few minutes into that window rather than at the start.
Lexirieru commentedon Oct 30, 2026
The exact commands for tomorrow, posted now so they can be wrong in public
@Lin1er — this is the part of #81 and #76 that went wrong on the day, not in the planning. Please read these for an error now rather than watching me run them.
The timelock is real, confirmed rather than assumed:
execute_upgradesimulated on dev right now returns23.4 hours remaining as of 2026-10-30 14:24 UTC. No amount of authorisation shortens it, which is the point of a constant delay rather than an admin-settable one.
Step 1 — dev only
Step 2 — the premise test, on dev, before production is touched
Required: byte-identical to the baseline pinned above, whose full-readback sha256 is
a9a103ea25660d448a02e9e8ee2048e59e024a437a10404714270072586654aa.claim_template()must still return the 8-part AdSense template. If it returnsnull,#[contracttype]enum keys are positional, #94's parallel-key design is wrong, and I stop — production stays on v0.4.0 and we talk.Also new on v0.5.0 and worth reading on dev:
Step 3 — production
Only after step 2 passes. Baseline sha256
f141d2435c55609be339fbdc862a1cdefaf69146c392466de1cbbb9c91caa64d;liquiditymust stay1050000000,claim_templatestaysnull.Step 4 — @AncungAulia rebuilds
NEXT_PUBLIC_CONTRACT_TAKES_SOURCE=1onforepay-vue5, then rebuild.Step 5 —
set_claim_ownerownerisBytes, andis_eth_addresswants the ASCII of the0x…string, 42 characters. So the CLI argument is hex-of-ASCII, not the 20 raw address bytes:That decodes to
0x6415200c713135e77157e1536d488df4f2bb7d04, 84 hex characters for 42 ASCII ones.I did not take this convention from the signature. I read the dev contract's stored
provider_hashback off chain and decoded it:ASCII, hex-encoded. Same shape as what
set_claim_templatetakes forprovider_hash, which is the other place this is easy to get wrong.Read it back afterwards and require the lowercase form, since
set_claim_ownerlowercases what it stores.Step 6 —
set_claim_template, AdMob onlypartsmust be exactly 8 or it returnsClaimMismatch. @Lin1er, when you runpin_template.py --source admob --commandon the real proof, that prints this line with the parts already hex-encoded — I would rather paste yours than assemble it, since the proof is yours and part 6 is 825 bytes.Simulate first and report the fee, both of us. #76's
set_claim_templatewanted 21,370 XLM in rent; the deployer holds 30,433.56 XLM. One template should fit — "should" is not "does", and the way to find out is--send=no, not a submitted transaction.Step 7 — then the real proof
Templates pinned first, then the account owner signs in, because a Reclaim proof is only accepted for about an hour.
What I will not do without saying so here first
renounce_upgradeability. Not until a real advance has been taken and The contract rebuilds the attestor's owner as the borrower, so no real proof can verify #102 is closed — it is a one-way door, and the only reason we can fix The contract rebuilds the attestor's owner as the borrower, so no real proof can verify #102 at all is that nobody has walked through it.Lin1er commentedon Oct 31, 2026
@Lexirieru — I read the runbook for errors, as you asked. Steps 1 to 5 check out. Step 6 has an error, and it came from my tool, not from you.
Steps 1–5
0x6415200c713135e77157e1536d488df4f2bb7d04, which isRECLAIM_APP_ID. That is 42 ASCII characters as 84 hex characters, the same convention as the storedprovider_hash.Step 6:
pin_template.py --commandprinted the v0.4.0 shape. It had nosource, and v0.5.0'sset_claim_template(source, parts, provider_hash)takes the source first, so the CLI would have refused the line as printed. The fix is in #110 (tool only; the parts and the checks are unchanged).This is the line the fixed tool prints from the real AdMob proof, for production. The parts carry no publisher id; that is one of the seven values interleaved between them, not part of the template.
provider_hashand same 8 parts as before (65/11/9/24/11/9/825/25 bytes). The derivation passes all three checks: round trip, structure, and the attestor's identifier.--source AdMobas a unit enum before v0.5.0 is live, so please simulate with--send=nofirst and post the fee, as you planned. If the CLI wants a different spelling, it will say so there.--id CD25Q4TDGDY6CI3LUIWUOH6SXCH6ETIUCI6FUOBI322GCJL5G3EIHQN4. Only pin AdMob there if you want dev to take AdMob too.claim_template_for --source AdMob.Relay side
api-forepay.jameshub.funwas down from about 16:15 UTC yesterday to 05:05 UTC today; the server lost its internet route. It is back at 200, and I am watching it through the window.mainatee05add, which already sendssourceand handlesempty. Nothing needs to deploy for the upgrade.Lin1er commentedon Oct 31, 2026
@Lexirieru: the relay is back.
https://api-forepay.jameshub.fun/healthhas returned 200 since about 14:20 UTC.It was down from about 06:00 UTC until then. The relay host's uplink dropped and took the tunnel with it. I fixed it on my side. Nothing changed in the code or the deployment.
On-chain, as of 14:20 UTC, both contracts still show the v0.5.0 proposal in
pending_upgrade(ff6a16e9…f22e), so step 1 of your runbook can run whenever you are ready. My AdMob tester is standing by. They will prove only after step 6, because the AdMob template has to be pinned before a proof can pass.Lexirieru commentedon Oct 31, 2026
v0.5.0 is live on both contracts, and the AdMob template is pinned. @Lin1er — your tester can prove now.
@Lin1er @Nabil-Aufa @AncungAulia — the chain work in the runbook is done. Every number below was read back from the ledger after the fact, not taken from a simulation.
execute_upgradedevCD25Q4TD…HQN49000b17f…4b33ebff6a16e9…e4f22e,pending_upgrade()→nullexecute_upgradeproductionCCQFL2Q6…I2HS8de3c144…116655ff6a16e9…e4f22e,pending_upgrade()→nullset_claim_ownerdev7402870d…ecc3a30x6415200c…bb7d04set_claim_ownerproduction0e5df000…c2e8c00x6415200c…bb7d04set_claim_template --source AdMobproduction01cc1878…3d00a7liquidity()is unchanged on both — 105 USDC on production, 2 USDC on dev.admin()is unchanged. Nothing was lost in the upgrade.The timelock, measured rather than assumed
Yesterday at 14:24 UTC the same simulated call returned
Error(Contract, #4)TimelockNotElapsed. Today at 14:21 UTC it returnedSuccesswithUpgradeExecutedcarryingff6a16e9…e4f22e.executable_atwas 1793454550 and 1793454560; the upgrade ran 26 minutes past the first. The delay is a constant in the contract, and the only thing that moved it was time.The premise test passed, and it is stronger than the one I promised
#94's whole premise is that
#[contracttype]enum storage keys encode by name, so adding aDataKeyvariant cannot shift an existing entry. Dev had the AdSense template pinned under v0.4.0. Across the upgrade:claim_template()(8 parts, 570 bytes)078604d2…d0d3aa078604d2…d0d3aaprovider_hash()b4813b68…c9e213b4813b68…c9e213Byte-identical. And
claim_template_for --source AdSenseon dev returns that same value, so the AdSense variant resolves onto the entry v0.4.0 wrote rather than to an empty new key.Production gives the complementary half of the proof. It now has AdMob pinned, while
claim_template()andclaim_template_for --source AdSenseboth still readnull. So the per-source entries are genuinely separate keys — pinning one did not retype or shadow the other. That is the thing #94 had to be true for, and it is now observed on chain in both directions.The fee: 0.29 XLM, not 21,370
@Lin1er, you asked me to simulate and post the fee before submitting, because of #76. Simulated
minResourceFeewas 3,368,292 stroops = 0.3368 XLM. Actual cost, from the balance before and after: 0.2926 XLM. #76's 21,370 XLM was rent on a TTL extension, not on these bytes.Your parts, verified rather than trusted
I did not paste your command. I re-derived the eight parts myself from
tools/fixtures/admob-claim.jsonthroughsplit_parts, and compared them to the hex in your comment: all 8 identical, lengths 65/11/9/24/11/9/825/25. That is a real check, because the parts are the literal segments of the request shape and do not depend on which proof produced them.One value I could not verify, and I am not going to pretend otherwise. The AdMob
provider_hash0x5d9a2fc4a5dc937ea6e0ad71539419ec47138cd8728d46a9b94b026b78238006appears nowhere in this repo — the fixture carries a0xcdcd…placeholder, and the only AdSense hash on record is0x569b9323…intools/rehearsal.py. So that value rests entirely on your real proof. Please confirm it against the signed context before your tester spends a proof on it.The failure mode if it is wrong is loud, not silent:
ClaimMismatch, no advance, no money moved, andset_claim_templatecan be run again. It is a wasted proof, not a wasted contract.@AncungAulia — this is now blocking, and it was not before
NEXT_PUBLIC_CONTRACT_TAKES_SOURCE=1on theforepay-vue5Vercel project, followed by a rebuild. @Nabil-Aufa called this on #106 on 2026-10-29: the momentexecute_upgraderuns, a front end built without the flag fails at accept, becauserequest_advancenow takessourcefirst and the arguments no longer line up.Two things make it urgent rather than catastrophic:
claim_template()wasnullbefore today, so the live app could not complete an advance anyway. Nothing that worked yesterday stopped working.NEXT_PUBLIC_*is inlined at build time. Setting the variable without a redeploy does nothing, and looks exactly the same as not setting it. That is the part that bites.I have no Vercel access, so I cannot check or do this, and I am not going to guess at it. If you post here once the rebuild is out, I will read
app.forepay.xyzand confirm.What is still not done
READYaccount earned zero in Jul–Sep 2026, andbe/src/adsense/account.tsrefuses before the attestor is called. AdMob working does not close an AdSense gate.renounce_upgradeabilityhas not been called and will not be until that happens. It is one-way, and it is the only reason today is fixable if the provider hash is wrong.fix(#102): pin_template --command names the source set_claim_template…
docs(#102,#94): v0.5.0 executed, claim owner and AdMob template pinned
Lin1er commentedon Nov 1, 2026
@Lexirieru: I read your runbook results back from the ledger on my side (2026-11-01 03:30 UTC,
--send=no). Both contracts match the real AdMob proof from 2026-10-26:CCQFL2…I2HSCD25Q4…HQN4pending_upgradenullnullclaim_owner0x6415200c…7d040x6415200c…7d04owner=0x6415200c…7d04provider_hash_for --source AdMob0x5d9a2fc4…80060x5d9a2fc4…8006context.providerHash=0x5d9a2fc4…8006claim_template_for --source AdMobThe proof's
identifier(0xa1ff3d94…17b2) recomputes from these values, so the attestor's signature covers what the contracts now expect.AdSense is still pinned on dev only. Production returns
nullfor bothclaim_template_forandprovider_hash_for --source AdSense, which is expected until an AdSense proof exists (#77).What's left on this issue is the live run: the tester proves AdMob through app.forepay.xyz and the advance lands on production. I'll post the transaction here when it does.
docs(#102,#94,#5): the first real advance, and a correction
Lexirieru commentedon Nov 2, 2026
It already happened. Two days ago, and nobody saw it.
@Lin1er @Nabil-Aufa @AncungAulia — the real AdMob advance landed on production on 2026-10-31 at 14:42:05 UTC, sixteen minutes after I pinned the template, and was repaid thirty seconds later. @Lin1er, your 03:30 UTC note on 2026-11-01 said "I'll post the transaction here when it does" — it had already been on chain for thirteen hours when you wrote that.
I found it today by reading the contract's events, not from anyone's report.
478b6121…faf227e141ff03…424d8fGBGVB5J2BMSKX44CS5NCNTIRLDSORMRUGV3SGB2L4GOCYEDXTZXPSSFE583f992c97f6ae5a05cb007833e6f789ef1fc716566113fa326d8dafc0cb1f77Events on the ledger, in order:
nullifier_spent,advance_disbursed(revenue_cents5935,principal148375000),repaid(outstanding0).advance(583f992c…cb1f77):pub_idpub-53127413133480902026-07-01→2026-09-30revenue_cents5935— $59.35 provenprincipal148375000— 14.8375 USDC, exactly 25%advance_source(nullifier)AdMobWhy this closes #102
#102's bug was that
request_advancerebuilt the EIP-191 digest with the borrower as the attestor'sowner, when the attestor signs for the requesting Reclaim app id. The pinnedclaim_owneris0x6415200c713135e77157e1536d488df4f2bb7d04, and a production attestor signature verified against it on chain and moved real USDC. That is the gate, and it is not the probe witnesstools/rehearsal.pysigns with. Closing.#94 is proven end to end as well:
advance_sourcereadsAdMobback by name, so theSourceargument travelled front end → relay → persistent storage and survived.Why it went unnoticed, which is the part worth keeping
liquidity()is1050000000— 105 USDC, exactly what it was before. The advance was repaid in full, so the contract looks untouched. Every state read I would normally use to check "did anything happen" returns the pre-advance value. The only durable trace is the event log and theAdvanceentry under its nullifier, and you have to know the nullifier to ask for it.Worth a follow-up: nothing watches this contract. #81's lesson was that an upgrade can idle after it becomes possible; this is the same shape with the sign flipped — the thing we were waiting for happened and idled unnoticed for two days. A single
getEventspoll on both contracts, posting here, would have caught it in minutes.A correction to what I wrote here on 2026-10-31
I wrote that there was no v0.4.0
Advanceto read back because "the rehearsal repaid in full, which removes the entry". That is wrong.repayends inenv.storage().persistent().set(&key, &advance)and never removes — the only.remove()calls in the contract are forDataKey::PendingUpgrade. This advance proves it: repaid in full, and still fully readable above.Why
advance()returnednullfor those three rehearsal nullifiers is still unknown. Dev shows no advance events at all in the RPC retention window, which does not fit the rehearsal having submitted them either. I am leaving that unknown rather than replacing one guess with another.docs/deployments.mdat88e1c95carries the correction.What is still open
#5 is not closed by this. It asks for one real AdSense proof, and this is AdMob. The digest construction, the owner gate, the sizing and the storage are now all proven against a real attestor — but AdSense still has no proof to verify, for the reason on #77. That issue has had no assignee since 2026-10-20, and it is now the only thing between us and the feasibility gate.
renounce_upgradeabilityis still uncalled. With a real advance now landed I would consider it in scope, but not before the AdSense half is settled.