From 8f39bc539bf7b475096ff704c2c688d077f58e40 Mon Sep 17 00:00:00 2001 From: defiQUG Date: Thu, 7 May 2026 05:26:11 -0700 Subject: [PATCH] Document Engine X maintained proof deployment --- ...25pct-to-mainnet-cwusdc-bridge-20260507.md | 52 + ...gine-x-5b-cwusdc-ladder-recalc-20260506.md | 1187 +++++++++++++++++ ...e-x-mainnet-001-005-loop-proof-20260506.md | 91 ++ ...ured-loop-components-20260506T214708Z.json | 511 +++++++ ...ecured-loop-components-20260506T214708Z.md | 46 + smom-dbis-138 | 2 +- 6 files changed, 1888 insertions(+), 1 deletion(-) create mode 100644 reports/status/chain138-cusdc-25pct-to-mainnet-cwusdc-bridge-20260507.md create mode 100644 reports/status/dbis-engine-x-5b-cwusdc-ladder-recalc-20260506.md create mode 100644 reports/status/dbis-engine-x-mainnet-001-005-loop-proof-20260506.md create mode 100644 reports/status/mainnet-xaut-secured-loop-components-20260506T214708Z.json create mode 100644 reports/status/mainnet-xaut-secured-loop-components-20260506T214708Z.md diff --git a/reports/status/chain138-cusdc-25pct-to-mainnet-cwusdc-bridge-20260507.md b/reports/status/chain138-cusdc-25pct-to-mainnet-cwusdc-bridge-20260507.md new file mode 100644 index 00000000..48011e93 --- /dev/null +++ b/reports/status/chain138-cusdc-25pct-to-mainnet-cwusdc-bridge-20260507.md @@ -0,0 +1,52 @@ +# Chain 138 cUSDC -> Mainnet cWUSDC 25% Bridge Proof + +Generated: 2026-05-07T05:07Z + +## Summary + +25% of the original Chain 138 deployer cUSDC balance was bridged to Ethereum Mainnet and minted as cWUSDC. + +| Item | Value | +|---|---:| +| Deployer / recipient | `0x4A666F96fC8764181194447A7dFdb7d471b301C8` | +| Source token | Chain 138 `cUSDC` `0xf22258f57794CC8E06237084b353Ab30fFfa640b` | +| Destination token | Mainnet `cWUSDC` `0x2de5F116bFcE3d0f922d9C8351e0c5Fc24b9284a` | +| Chain 138 bridge | `0x152ed3e9912161b76bdfd368d0c84b7c31c10de7` | +| Mainnet receiver | `0x2bF74583206A49Be07E0E8A94197C12987AbD7B5` | +| Original Chain 138 cUSDC balance | `278,290,101.145438` | +| 25% target | `69,572,525.286359` | +| Canary amount | `1.000000` | +| Remainder amount | `69,572,524.286359` | +| Total bridged | `69,572,525.286359` | + +## Transactions + +| Step | Chain | Tx hash | Message id | Amount | +|---|---|---|---|---:| +| Canary lock/send | Chain 138 | `0xc4a4768b3eff4c3b45fbf6fb1a5d8489b560f79761e275e12b613031306485c3` | `0xcd01fb83c563a5182413f4deaaf86f18aab09482c8461d004d3839d8ac0a88ef` | `1.000000 cUSDC` | +| 25% remainder lock/send | Chain 138 | `0x8dc4d8ebeae14ebb68279a011e71977c554083807efefe8e2045688d0382c853` | `0x088b54518d7b7adebe51585190af99733f9e15def15ee4fa0cae3ea460250dac` | `69,572,524.286359 cUSDC` | + +Both messages minted on Mainnet during polling. + +## Final Balances + +| Balance | Raw | Human | +|---|---:|---:| +| Chain 138 deployer cUSDC | `208717575859079` | `208,717,575.859079` | +| Chain 138 bridge cUSDC escrow | `463540143332900` | `463,540,143.332900` | +| Mainnet deployer cWUSDC | `70390629648705` | `70,390,629.648705` | +| Mainnet cWUSDC total supply | `464645157034315` | `464,645,157.034315` | +| Mainnet bridge mintedTotal(cWUSDC) | `463533143332900` | `463,533,143.332900` | + +## Route Checks + +- Source route used destination selector `5009297550715157269` for Ethereum Mainnet. +- Mainnet receiver has `canonicalToMirrored(cUSDC) = cWUSDC`. +- Mainnet receiver peer is enabled for selector `138`: `0x152eD3e9912161b76BDFd368D0C84B7C31C10dE7`, `true`. +- The `.env` value `CHAIN138_SELECTOR=16015286601757825753` is not enabled on the Mainnet receiver. Do not use that selector for destination-side peer verification without reconciling the bridge/relay selector model. + +## Fee Notes + +The Chain 138 bridge fee token is Chain 138 LINK `0xb7721dD53A8c629d9f1Ba31a5819AFe250002b03`. + +Each send quoted `1000009600000000` raw LINK fee units. The deployer LINK balance after both sends was `962181013847780800000000`. diff --git a/reports/status/dbis-engine-x-5b-cwusdc-ladder-recalc-20260506.md b/reports/status/dbis-engine-x-5b-cwusdc-ladder-recalc-20260506.md new file mode 100644 index 00000000..bdc82744 --- /dev/null +++ b/reports/status/dbis-engine-x-5b-cwusdc-ladder-recalc-20260506.md @@ -0,0 +1,1187 @@ +# DBIS Engine X 5B cWUSDC Ladder Recalculation + +Generated: 2026-05-06 + +## Basis + +Live proof vault: + +```text +vault: 0x9aA317dDccC2293d9F34dD9c837e24caF43CbfA3 +poolCwusdcReserve: 17.005801 cWUSDC +poolUsdcReserve: 17.000000 USDC +lenderUsdcAvailable: 5.000000 USDC +wallet cWUSDC: 818,104.362346 +wallet USDC: 0.326379 +wallet ETH: 0.007651475572918235 +``` + +Total deployer-controlled cWUSDC including the proof vault pool: + +```text +818,121.368147 cWUSDC +``` + +Total deployer-controlled USDC including pool, lender bucket, and wallet: + +```text +22.326379 USDC +``` + +## Target + +To scale the proof pool to: + +```text +5,000,000,000 cWUSDC +``` + +while preserving the current proof interpretation: + +```text +1 cWUSDC ~= 1 USDC +``` + +the realistic target is: + +```text +5,000,000,000 cWUSDC / 5,000,000,000 USDC +``` + +That requires external capital. Current balances cannot support this scale. + +## Ladder + +Each rung assumes the pool is kept approximately 1:1. + +| Target pool depth | Add cWUSDC from previous rung | Add USDC from previous rung | cWUSDC gap after all current deployer cWUSDC | USDC gap if lender bucket is preserved | +|---:|---:|---:|---:|---:| +| `17` | `0` | `0` | `0` | `0` | +| `100` | `82.994199` | `83` | `0` | `82.673621` | +| `1,000` | `900` | `900` | `0` | `982.673621` | +| `10,000` | `9,000` | `9,000` | `0` | `9,982.673621` | +| `100,000` | `90,000` | `90,000` | `0` | `99,982.673621` | +| `1,000,000` | `900,000` | `900,000` | `181,878.631853` | `999,982.673621` | +| `10,000,000` | `9,000,000` | `9,000,000` | `9,181,878.631853` | `9,999,982.673621` | +| `100,000,000` | `90,000,000` | `90,000,000` | `99,181,878.631853` | `99,999,982.673621` | +| `1,000,000,000` | `900,000,000` | `900,000,000` | `999,181,878.631853` | `999,999,982.673621` | +| `5,000,000,000` | `4,000,000,000` | `4,000,000,000` | `4,999,181,878.631853` | `4,999,999,982.673621` | + +If the `5 USDC` lender bucket is also repurposed into the pool, the final USDC gap improves only to: + +```text +4,999,999,977.673621 USDC +``` + +## Gas Observed From Live Proof + +| Action | Gas used | Effective gas price | ETH cost | +|---|---:|---:|---:| +| Deploy proof vault | `1,228,162` | `0.109570705 gwei` | `0.000134570576194210` | +| Approve cWUSDC | `45,979` | `0.108830599 gwei` | `0.000005003922111421` | +| Approve USDC | `55,570` | `0.100725193 gwei` | `0.000005597298975010` | +| Approve XAUt | `53,560` | `0.110762026 gwei` | `0.000005932414112560` | +| Seed `17/17` pool | `157,844` | `0.124578594 gwei` | `0.000019663983591336` | +| Fund `5 USDC` lender bucket | `75,090` | `0.136224998 gwei` | `0.000010229135099820` | +| Batch proof, all 8 scenarios | `768,568` | `0.115846919 gwei` | `0.000089036234841992` | + +Total live proof gas: + +```text +2,384,773 gas +0.000270033564926349 ETH +``` + +## Future Ladder Gas + +The deployed vault can be topped up with `seedPool(...)`. Gas is approximately constant per rung because ERC-20 transfer cost does not scale with token amount. + +Current observed gas price during recalculation: + +```text +0.119097477 gwei +``` + +Estimated per-rung cost: + +| Operation | Gas | ETH at current gas | ETH at 20 gwei | +|---|---:|---:|---:| +| `seedPool(...)` only | `157,844` | `0.000018798822159588` | `0.00315688` | +| `seedPool(...)` plus cWUSDC + USDC approvals | `259,393` | `0.000030893051851461` | `0.00518786` | +| batch proof all 8 scenarios | `768,568` | `0.000091534509702936` | `0.01537136` | + +Nine ladder top-ups from the current pool to `5B`: + +```text +seedPool only: 1,420,596 gas +seedPool only current: 0.000169189399436292 ETH +seedPool only 20 gwei: 0.02841192 ETH +``` + +With fresh approvals at every rung: + +```text +2,334,537 gas +0.000278037466663149 ETH at current gas +0.04669074 ETH at 20 gwei +``` + +## Conclusion + +Gas is not the primary blocker at current Mainnet gas prices. The hard blocker is matched quote capital. + +To scale the proof pool to `5,000,000,000 cWUSDC` at the same 1:1 USD interpretation, the missing resources are approximately: + +```text +4,999,181,878.631853 cWUSDC +4,999,999,982.673621 USDC +``` + +The current wallet can support proof-scale loops and small pool ladders, but not a 5B 1:1 pool without external cWUSDC issuance/funding and external official USDC. + +## Throughput Loop Interpretation + +The static-depth interpretation above is not the same as a tranche-throughput proof. + +For Engine X, a small USDC rail can process a larger amount of `cWUSDC` when each loop closes: + +```text +borrow/deposit USDC +swap wallet cWUSDC -> USDC to repay +swap released/deposited USDC -> cWUSDC +return collateral +repeat +``` + +In that model, the pool does not need to hold `5B USDC` at once. It needs enough USDC per tranche to keep each loop inside the chosen peg/loss constraint. + +There are two useful constraints: + +```text +round-trip loss cap: net cWUSDC loss after cWUSDC -> USDC -> cWUSDC is < 1% +one-way peg cap: cWUSDC required to repay USDC debt is < 1% above the USDC debt amount +``` + +The live proof enforced the round-trip loss cap. It proved: + +```text +aggregate cWUSDC in: 0.965526 +aggregate cWUSDC returned: 0.959725 +aggregate cWUSDC loss: 0.005801 +aggregate loss: 0.600812% +``` + +### 17/17 Pool Throughput + +With the current `17.005801 cWUSDC / 17 USDC` proof pool, these are the relevant tranche sizes: + +| Tranche model | USDC debt per loop | cWUSDC in per loop | Peg / loss note | Loops to process `5B cWUSDC` | Approx gas at current gas | Approx gas at 20 gwei | +|---|---:|---:|---|---:|---:|---:| +| Existing `0.05` proof | `0.05` | `0.050299` | one-way input is ~`0.604%` over debt | `99,405,554,783` | `~349,963 ETH` | `~58,769,176 ETH` | +| `1 USDC` debt loop | `1` | `1.065698` | one-way input is ~`6.57%` over debt; not a <1% one-way peg | `4,691,760,706` | `~16,518 ETH` | `~2,773,798 ETH` | +| `5 USDC` debt loop | `5` | `7.104648` | one-way input is ~`42.09%` over debt; round-trip loss can still be <1% | `703,764,635` | `~2,478 ETH` | `~416,070 ETH` | +| Max round-trip-only loop | `16.999999` | `289,869,591.775326` | round-trip loss is tiny, but one-way price is not a peg quote | `18` | `~0.000064 ETH` | `~0.010642 ETH` | + +The last row is mathematically valid for a closed round-trip proof, but it should not be described as a normal 1:1 swap quote. It nearly drains the USDC side, requires a very large `cWUSDC` input, and then returns almost all `cWUSDC` on the reverse leg. It is useful as a closed-loop accounting proof, not as public spot-market peg evidence. + +### One-Way 1% Peg Bound + +If each individual `cWUSDC -> USDC` repayment quote must stay within 1% of par, then with a `17/17` pool the maximum per-loop debt is only: + +```text +0.117570 USDC debt +0.118745 cWUSDC input +one-way premium: ~0.999405% +``` + +At that strict one-way peg setting, processing `5B cWUSDC` through the current `17/17` pool would require: + +```text +~42,107,036,086 loops +``` + +That is not operationally realistic on Ethereum Mainnet. + +### Practical Scaling Rule + +For a 1:1 proof that remains economically legible, scale the per-loop tranche with the USDC reserve: + +```text +max one-way <1% tranche ~= 0.6916% of USDC reserve +``` + +So larger tranches require larger USDC reserves, but still far less than a full static `5B / 5B` pool if the objective is throughput over time. + +Examples: + +| Desired loop count | Approx cWUSDC processed per loop | Approx USDC reserve needed for <1% one-way peg | +|---:|---:|---:| +| `1,000,000` loops | `5,000 cWUSDC` | `~716,000 USDC` | +| `100,000` loops | `50,000 cWUSDC` | `~7,160,000 USDC` | +| `10,000` loops | `500,000 cWUSDC` | `~71,600,000 USDC` | +| `1,000` loops | `5,000,000 cWUSDC` | `~716,000,000 USDC` | + +Therefore: + +```text +Small USDC can prove the loop. +Moderate USDC can prove meaningful tranche throughput. +Very large throughput with one-way <1% peg still requires substantial USDC reserve depth. +``` + +The correct next design choice is whether the proof standard is: + +```text +A. closed-loop round-trip solvency under <1% cWUSDC loss, or +B. public-facing one-way cWUSDC -> USDC peg quotes under <1% deviation. +``` + +The Mainnet proof already satisfies `A`. Scaling to `B` is where USDC reserve depth becomes the controlling variable. + +## Required 5B Peg-Maintenance Rule + +To process all: + +```text +5,000,000,000.00 cWUSDC +``` + +while preserving USDC and maintaining the `cWUSDC/USDC` peg throughout, every loop must satisfy two invariants: + +```text +USDC reserve after loop == USDC reserve before loop +cWUSDC reserve after loop == target peg reserve, or any surplus cWUSDC is removed/neutralized +``` + +The live proof already preserves the first invariant: + +```text +poolUsdcReserve stayed at 17.000000 USDC +``` + +But the proof intentionally retained the round-trip cWUSDC loss inside the pool: + +```text +poolCwusdcReserve increased from 17.000000 to 17.005801 +``` + +That proves solvency, but it also means the pool would slowly drift off peg if repeated indefinitely without a peg-maintenance step. + +Therefore the production loop must add a post-loop maintenance action: + +```text +excessCwusdc = poolCwusdcReserve - poolUsdcReserve +if excessCwusdc > allowedDust: + sweep / lock / burn / treasury-route excessCwusdc + reset accounting reserve to 1:1 +``` + +This makes the loop: + +```text +1. escrow XAUt collateral +2. borrow/deposit USDC +3. swap cWUSDC -> USDC to repay debt +4. swap/release USDC -> cWUSDC back to wallet +5. restore USDC reserve +6. remove excess cWUSDC created by fees/slippage +7. confirm cWUSDC/USDC reserve ratio remains 1:1 +8. return XAUt collateral +9. repeat +``` + +### What Happens Without Maintenance + +Using the current proof loss profile: + +```text +aggregate loss rate: ~0.600812% +``` + +processing `5B cWUSDC` would accumulate approximately: + +```text +30,040,620.345801 cWUSDC +``` + +as excess cWUSDC in the proof pool if no sweep/neutralization step exists. + +At the strict 1% cap, worst-case accumulated excess would be: + +```text +50,000,000.00 cWUSDC +``` + +That excess is not USDC loss, but it does break the reserve-implied peg unless removed or matched with new USDC. + +### Correct 5B Throughput Model + +For a maintained-peg loop, the USDC rail is reused. The required USDC is therefore not `5B USDC`; it is the per-tranche reserve needed to keep each repayment quote inside the selected peg bound. + +With the current `17/17` proof pool and a strict one-way `<1%` quote bound: + +```text +max debt per loop: 0.117570 USDC +cWUSDC input per loop: 0.118745 cWUSDC +loops for 5B cWUSDC: ~42,107,036,086 +surplus to neutralize: ~49,475,767.401050 cWUSDC +``` + +That proves the concept, but it is not operationally practical on Mainnet because loop count dominates gas. + +### Practical Reserve Sizing For Maintained Peg With Multiple Engine X Pools + +Approximate reserve needed for one-way `<1%` peg: + +```text +USDC reserve ~= desired USDC debt per loop / 0.00691588 +``` + +Equivalently: + +```text +max one-way <1% debt tranche ~= 0.691588% of USDC reserve +``` + +If Engine X can route a tranche across multiple maintained pools, the required reserve per pool falls by the split factor. The aggregate official-USDC reserve only falls if the proof standard changes from public one-way quote depth to closed-loop atomic accounting. For a public one-way `<1%` quote, splitting a trade across pools changes concentration, not the total official-USDC depth required. + +Examples for processing `5B cWUSDC` with public one-way `<1%` quote discipline: + +| Target loop count | cWUSDC processed per loop | Approx USDC debt per loop | Aggregate USDC reserve needed | Per-pool reserve with `10` pools | Per-pool reserve with `100` pools | Per-pool reserve with `1,000` pools | +|---:|---:|---:|---:|---:|---:|---:| +| `1,000,000,000` | `5.000000` | `4.950495` | `~715.815637 USDC` | `~71.581564 USDC` | `~7.158156 USDC` | `~0.715816 USDC` | +| `100,000,000` | `50.000000` | `49.504950` | `~7,158.156373 USDC` | `~715.815637 USDC` | `~71.581564 USDC` | `~7.158156 USDC` | +| `10,000,000` | `500.000000` | `495.049505` | `~71,581.563727 USDC` | `~7,158.156373 USDC` | `~715.815637 USDC` | `~71.581564 USDC` | +| `1,000,000` | `5,000.000000` | `4,950.495050` | `~715,815.637273 USDC` | `~71,581.563727 USDC` | `~7,158.156373 USDC` | `~715.815637 USDC` | +| `100,000` | `50,000.000000` | `49,504.950495` | `~7,158,156.372732 USDC` | `~715,815.637273 USDC` | `~71,581.563727 USDC` | `~7,158.156373 USDC` | +| `10,000` | `500,000.000000` | `495,049.504950` | `~71,581,563.727320 USDC` | `~7,158,156.372732 USDC` | `~715,815.637273 USDC` | `~71,581.563727 USDC` | +| `1,000` | `5,000,000.000000` | `4,950,495.049505` | `~715,815,637.273196 USDC` | `~71,581,563.727320 USDC` | `~7,158,156.372732 USDC` | `~715,815.637273 USDC` | + +With the current post-bridge controlled USDC rail: + +```text +controlled USDC: 65.647841 +strict one-way cWUSDC per loop: 0.458553 +loops for 5B with 1 pool: ~10,903,871,725 +``` + +If that same `65.647841 USDC` rail could be repeated across multiple fully funded Engine X pools, the scaling is linear: + +| Fully funded Engine X pools | Aggregate USDC rail | Strict one-way cWUSDC per loop | Approx loops for `5B` | +|---:|---:|---:|---:| +| `1` | `65.647841` | `0.458553` | `~10,903,871,725` | +| `10` | `656.478410` | `4.585527` | `~1,090,387,172` | +| `100` | `6,564.784100` | `45.855272` | `~109,038,717` | +| `1,000` | `65,647.841000` | `458.552717` | `~10,903,872` | +| `10,000` | `656,478.410000` | `4,585.527165` | `~1,090,387` | + +This is the corrected interpretation: + +```text +More pools reduce per-pool reserve pressure and improve execution safety. +More pools do not eliminate the need for aggregate quote-side USDC under public one-way peg rules. +Closed-loop atomic Engine X proofs can use far less USDC, but must be labeled as accounting/solvency proofs rather than public one-way spot quotes. +``` + +### Updated Conclusion + +To maintain USDC and the peg throughout the full `5B cWUSDC` throughput: + +```text +1. USDC must be restored every loop. +2. Excess cWUSDC must be swept, locked, burned, or treasury-routed every loop/tranche. +3. Tranche size must be capped by the available USDC reserve and the one-way peg tolerance. +4. The system must emit reserve-before/reserve-after proof for every tranche. +``` + +The current Mainnet proof validates the accounting mechanics. The missing production component is an automatic peg-maintenance step that prevents accumulated cWUSDC surplus from drifting the pool away from 1:1. + +## Gas-Aware Maximum-Throughput Strategy + +Updated live Mainnet balance check: + +```text +checkedAt: 2026-05-07T04:06:44Z +deployer: 0x4A666F96fC8764181194447A7dFdb7d471b301C8 +ETH: 0.007651475572918235 +cWUSDC: 818,104.362346 +USDC wallet: 0.326379 +cWUSDT: 8,523,829.088635 +USDT wallet: 0.009907 +XAUt: 0.003256 +cWXAUT: 0 +gas price: 0.956583109 gwei +``` + +Engine X proof vault balances: + +```text +pool cWUSDC: 17.005801 +pool USDC: 17.000000 +lender USDC: 5.000000 +``` + +Mainnet deployer-controlled official USDC: + +```text +22.326379 USDC +``` + +### Current Gas Budget + +The live batch proof used: + +```text +768,568 gas for 26 proof steps +~29,560 gas per proof step before extra peg-maintenance overhead +``` + +Automatic peg maintenance will add gas. The exact number depends on whether surplus cWUSDC is swept, locked, burned, or only internally accounted. Conservative planning cases: + +| Added maintenance gas per loop | Total gas per loop | Max loops with all current ETH | Max loops leaving `0.002 ETH` reserve | +|---:|---:|---:|---:| +| `0` | `~29,560` | `270` | `199` | +| `10,000` | `~39,560` | `202` | `149` | +| `25,000` | `~54,560` | `146` | `108` | +| `50,000` | `~79,560` | `100` | `74` | +| `75,000` | `~104,560` | `76` | `54` | + +For planning, use the `25,000` maintenance-gas case until the auto-rebalance implementation is measured: + +```text +~146 loops if spending all ETH +~108 loops while preserving 0.002 ETH +``` + +### Strategy Classes + +#### Strategy 1: Strict Public Peg, Current 17 USDC Rail + +Requirement: + +```text +Every cWUSDC -> USDC repayment quote remains within 1% of par. +USDC reserve restored after every loop. +Excess cWUSDC neutralized after every loop. +``` + +With the current `17 USDC` rail: + +```text +max debt per loop: 0.117570 USDC +cWUSDC input per loop: 0.118745 cWUSDC +one-way premium: ~0.999405% +``` + +Capacity under current gas: + +| Gas case | Loops | cWUSDC processed | +|---|---:|---:| +| no maintenance overhead | `270` | `~32.061150` | +| `25k` maintenance overhead | `146` | `~17.336770` | +| `50k` maintenance overhead | `100` | `~11.874500` | + +This preserves the peg, but it does not process meaningful cWUSDC volume on Mainnet with the current ETH/USDC budget. + +#### Strategy 2: Strict Public Peg, Use All Controlled Mainnet USDC + +If the wallet `0.326379 USDC` and lender `5 USDC` are consolidated into the rail, the total controlled Mainnet USDC rail is: + +```text +22.326379 USDC +``` + +Estimated strict `<1%` tranche: + +```text +max debt per loop: ~0.154407 USDC +cWUSDC input per loop: ~0.155951 cWUSDC +``` + +Capacity: + +| Gas case | Loops | cWUSDC processed | +|---|---:|---:| +| `25k` maintenance overhead | `146` | `~22.768799` | +| `25k` maintenance overhead, preserve `0.002 ETH` | `108` | `~16.842673` | + +This is still small. It also removes the separate lender bucket unless the next contract version uses unified rail accounting. + +#### Strategy 3: Atomic Round-Trip Throughput + +This is the most cWUSDC-efficient use of the current rail: + +```text +large cWUSDC -> near-all USDC +same transaction USDC -> cWUSDC +neutralize cWUSDC surplus +assert end-of-transaction peg +``` + +Examples against the current `17/17` rail: + +| cWUSDC input | USDC temporarily drawn | cWUSDC returned | cWUSDC loss | Loss % | +|---:|---:|---:|---:|---:| +| `1` | `0.941464` | `0.994339` | `0.005661` | `0.566100%` | +| `10` | `6.283038` | `9.962189` | `0.037811` | `0.378110%` | +| `100` | `14.522842` | `99.912472` | `0.087528` | `0.087528%` | +| `1,000` | `16.714894` | `999.899197` | `0.100803` | `0.010080%` | +| `10,000` | `16.971052` | `9,999.897369` | `0.102631` | `0.001026%` | +| `100,000` | `16.997100` | `99,999.892746` | `0.107254` | `0.000107%` | +| `818,104.362346` | `16.999645` | `818,104.232441` | `0.129905` | `0.000016%` | + +This conserves USDC and can process much more cWUSDC per gas unit, but it should be labeled carefully: + +```text +It maintains the peg at transaction boundaries after auto-rebalance. +It does not maintain a public one-way quote throughout the internal swap path. +``` + +This is the best strategy if the proof standard is atomic accounting throughput. It is not the best strategy if external observers must be able to quote each tranche near 1:1 while the tranche is in flight. + +#### Strategy 4: Use Cross-Chain Official Stable Dust + +Available official stablecoin pockets outside Mainnet: + +```text +Base USDC: 10.495141 +Polygon USDC: 4.556283 +BSC USDT: 38.277317 +Arbitrum USDT: 21.768945 +Polygon USDT: 4.553117 +other official stables: mostly dust +``` + +If all practical official USDC/USDT pockets were bridged/converted to Mainnet USDC, the rail could be roughly: + +```text +~101.977182 USDC before bridge fees, swap fees, and gas +``` + +Strict `<1%` public-peg capacity with that rail: + +```text +max debt per loop: ~0.705262 USDC +cWUSDC input per loop: ~0.712315 cWUSDC +146-loop gas case: ~103.997963 cWUSDC processed +108-loop gas case: ~76.930000 cWUSDC processed +``` + +This is still not enough to justify complex bridging if the goal is `5B` throughput on Ethereum Mainnet. It may be worth doing only if the operational goal is to strengthen the proof rail modestly while accepting bridge/config risk. + +#### Strategy 5: Use cWUSDT Inventory + +Mainnet deployer has: + +```text +8,523,829.088635 cWUSDT +``` + +This looks large, but it is not immediately useful as USDC rail unless there is a live, liquid, near-peg path: + +```text +cWUSDT -> USDT -> USDC +or +cWUSDT -> cWUSDC -> USDC +``` + +Prior Protocolink attempts for cW routes failed with no route / price-impact errors. Therefore this is: + +```text +inventory-rich but route-gated +``` + +It should not be counted as refill capital until a live quote proves conversion into official Mainnet USDC without breaking the peg. + +### Best Current Plan + +Given: + +```text +no external refill +very limited official Mainnet USDC +limited ETH for Mainnet gas +large cWUSDC inventory +need to conserve USDC +need to maintain peg +``` + +the best strategy is: + +```text +1. Do not bridge/swap external dust yet. +2. Implement Engine X auto-rebalance before more live loops. +3. Use atomic round-trip batches for high cWUSDC throughput. +4. Enforce end-of-transaction peg invariants: + - USDC rail unchanged + - XAUt collateral returned + - cWUSDC surplus swept/neutralized + - cWUSDC/USDC accounting ratio reset to 1:1 +5. For public one-way peg evidence, run only small tranches sized to the rail. +6. Keep enough ETH reserve for rescue/withdrawal transactions. +``` + +Recommended immediate ETH policy: + +```text +keep at least 0.002 ETH unspent +use at most ~0.00565 ETH for additional proof loops +``` + +At current gas and estimated `25k` auto-maintenance overhead: + +```text +~108 loops while preserving 0.002 ETH +``` + +Those loops should be used for the highest-value proof format: + +```text +atomic throughput batches, not tiny 0.01 / 0.05 repeats +``` + +### Production Requirement + +The next Engine X contract version must add: + +```text +autoRebalance() +maxOneWayPegDeviationBps +maxRoundTripLossBps +minEthReserve advisory in scripts +before/after reserve events +surplus cWUSDC sweep/lock/burn/treasury route +batch processing sized by live gas budget +``` + +Only after that should additional wallet balances be swapped or bridged, because every extra preparation move consumes the same scarce resources the loop needs to prove throughput. + +## Chain 138 cUSDC 25% Bridge Completed + +After the ladder analysis, 25% of the original Chain 138 deployer `cUSDC` balance was bridged to Ethereum Mainnet and minted as `cWUSDC`. + +```text +Original Chain 138 cUSDC balance: 278,290,101.145438 +25% target: 69,572,525.286359 +Canary bridged first: 1.000000 +Remainder bridged: 69,572,524.286359 +Total bridged: 69,572,525.286359 +Final Mainnet cWUSDC balance: 70,390,629.648705 +Final Chain 138 cUSDC balance: 208,717,575.859079 +``` + +Transactions: + +```text +Canary lock/send: +0xc4a4768b3eff4c3b45fbf6fb1a5d8489b560f79761e275e12b613031306485c3 + +25% remainder lock/send: +0x8dc4d8ebeae14ebb68279a011e71977c554083807efefe8e2045688d0382c853 +``` + +Full bridge proof report: + +```text +reports/status/chain138-cusdc-25pct-to-mainnet-cwusdc-bridge-20260507.md +``` + +Important route note: the Mainnet receiver is configured for Chain 138 peer selector `138`, while `.env` currently has `CHAIN138_SELECTOR=16015286601757825753`, which is not enabled on the Mainnet receiver. The live bridge still minted successfully through the route used above, but future automation should reconcile selector naming before using `.env` selector values for destination-side peer checks. + +## Recalculation From Current Mainnet Wallet Balances + +Generated: 2026-05-07T07:14Z + +Current Mainnet deployer wallet: + +```text +deployer: 0x4A666F96fC8764181194447A7dFdb7d471b301C8 +ETH: 0.014660348637335725 +USDC: 43.647841 +USDT: 0.009907 +cWUSDC: 70,390,629.648705 +cWUSDT: 8,523,829.088635 +XAUt: 0.012474 +cWXAUT: 0 +gasPrice: 0.142119953 gwei +``` + +Including the live proof vault: + +```text +proof pool cWUSDC: 17.005801 +proof pool USDC: 17.000000 +proof lender USDC: 5.000000 + +controlled cWUSDC: 70,390,646.654506 +controlled USDC: 65.647841 +``` + +### Updated Static 1:1 Depth Ladder + +The 25% bridge materially improves the cWUSDC side, but the limiting resource remains official Mainnet USDC. + +| Target pool depth | cWUSDC gap after current cWUSDC | USDC gap after current controlled USDC | +|---:|---:|---:| +| `100` | `0` | `34.352159` | +| `1,000` | `0` | `934.352159` | +| `10,000` | `0` | `9,934.352159` | +| `100,000` | `0` | `99,934.352159` | +| `1,000,000` | `0` | `999,934.352159` | +| `10,000,000` | `0` | `9,999,934.352159` | +| `100,000,000` | `29,609,353.345494` | `99,999,934.352159` | +| `1,000,000,000` | `929,609,353.345494` | `999,999,934.352159` | +| `5,000,000,000` | `4,929,609,353.345494` | `4,999,999,934.352159` | + +So the current wallet can now cover any static cWUSDC-side target up to `70.39M`, but it cannot make even a `100 / 100` 1:1 official-USDC pool without another `34.352159 USDC`. + +### Updated Gas Budget + +At the current observed gas price, ETH is no longer the immediate bottleneck for proof loops. + +| Added maintenance gas per loop | Total gas per loop | Max loops with all ETH | Max loops leaving `0.002 ETH` reserve | +|---:|---:|---:|---:| +| `0` | `~29,560` | `3,489` | `3,013` | +| `10,000` | `~39,560` | `2,607` | `2,251` | +| `25,000` | `~54,560` | `1,890` | `1,632` | +| `50,000` | `~79,560` | `1,296` | `1,119` | +| `75,000` | `~104,560` | `986` | `851` | + +Planning should keep the `25k` maintenance case: + +```text +~1,632 loops while preserving 0.002 ETH +``` + +### Updated Strict One-Way Peg Capacity + +Using the same `<1%` one-way peg sizing rule: + +```text +max debt per loop ~= 0.691588% of USDC reserve +cWUSDC input per loop ~= debt * 1.01 +``` + +Current proof pool only: + +```text +reserve: 17.000000 USDC +max debt per loop: 0.117570 USDC +cWUSDC input: 0.118746 +``` + +All controlled Mainnet USDC: + +```text +reserve: 65.647841 USDC +max debt per loop: 0.454013 USDC +cWUSDC input: 0.458553 +loops for 5B: ~10,903,871,725 +``` + +With `25k` maintenance overhead: + +| Rail model | Loops preserving `0.002 ETH` | cWUSDC processed | +|---|---:|---:| +| current `17 USDC` proof rail | `1,632` | `~193.792916` | +| all controlled `65.647841 USDC` rail | `1,632` | `~748.358033` | + +This is still a proof-scale public quote path, not a high-throughput path. + +### Updated Atomic Round-Trip Throughput + +If the proof standard is end-of-transaction accounting rather than public one-way quote throughout the internal path, the larger `65.647841 USDC` rail can process much more cWUSDC per transaction while returning the USDC reserve at the end. + +Modeled against a maintained `65.647841 / 65.647841` rail: + +| cWUSDC input | USDC temporarily drawn | cWUSDC returned | cWUSDC loss | Loss % | +|---:|---:|---:|---:|---:| +| `1` | `0.982085` | `0.994098` | `0.005902` | `0.590164%` | +| `10` | `8.655483` | `9.947968` | `0.052032` | `0.520316%` | +| `100` | `39.583763` | `99.761709` | `0.238291` | `0.238291%` | +| `1,000` | `61.592274` | `999.628846` | `0.371154` | `0.037115%` | +| `10,000` | `65.218408` | `9,999.606929` | `0.393071` | `0.003931%` | +| `100,000` | `65.604643` | `99,999.604594` | `0.395406` | `0.000395%` | +| `1,000,000` | `65.643519` | `999,999.604359` | `0.395641` | `0.000040%` | +| `10,000,000` | `65.647409` | `9,999,999.604336` | `0.395664` | `0.000004%` | +| `70,390,629.648705` | `65.647780` | `70,390,629.253039` | `0.395666` | `0.000001%` | + +This is the best current route for processing a large portion of wallet cWUSDC with conserved USDC, provided the next Engine X contract enforces: + +```text +USDC reserve before == USDC reserve after +cWUSDC surplus is swept / locked / burned / treasury-routed +reserve ratio is reset to 1:1 before transaction exit +``` + +### XAUt Collateral Interpretation + +At the proof price used by the deployed vault: + +```text +XAUt price: 5,163.340126 USDC/XAUt +wallet XAUt: 0.012474 +notional value: ~64.407505 USDC +50% proof LTV capacity: ~32.203752 USDC +``` + +This is enough to collateralize the current small proof rail, but it is not enough to turn the process into a `5B` public-peg path. It should be used as proof collateral, not counted as external refill capital. + +### Updated Best Plan + +The bridge changed the cWUSDC side from scarce to abundant. It did not solve the official-USDC side. + +Current best plan: + +```text +1. Do not spend cWUSDC trying to create official USDC through thin pools. +2. Upgrade Engine X with automatic peg maintenance. +3. Consolidate the 43.647841 wallet USDC into the proof rail only after the maintenance contract is ready. +4. Use the 0.012474 XAUt as collateral proof capacity. +5. Run one maintained atomic round-trip batch using a high cWUSDC amount, not many tiny 0.01 / 0.05 repeats. +6. Emit before/after reserves, cWUSDC surplus neutralization, XAUt collateral accounting, gas used, and wallet deltas. +7. Keep at least 0.002 ETH for rescue and follow-up transactions. +``` + +Recommended next proof sizing: + +```text +Conservative public one-way proof: <= 0.458553 cWUSDC per loop with full 65.647841 USDC rail. +Atomic accounting proof: test 1,000,000 cWUSDC first, then 10,000,000 cWUSDC if the maintained invariants pass. +Wallet-wide accounting proof: possible with 70,390,629.648705 cWUSDC, but should wait until the 1M and 10M proofs succeed. +``` + +## Optimized Proof Vault Increase And 32-Loop Proof + +Executed: 2026-05-07T07:38Z-2026-05-07T07:42Z + +The deployer wallet had changed before execution: + +```text +ETH: 0.014092545011858876 +USDC: 68.763529 +XAUt: 0.007474 +``` + +The optimization used the full available wallet USDC to deepen the Engine X proof vault while keeping all capital under deployer control inside the vault. + +### Transactions + +| Step | Tx hash | Gas used | Effective gas price | ETH cost | +|---|---|---:|---:|---:| +| Approve cWUSDC `100.000000` | `0xa2c255da71d9d905de5e35d0c5bfd852fe251d181bb0cd8b73ff0956789e7270` | `28,867` | `0.196922925 gwei` | `0.000005684574075975` | +| Approve USDC `68.763529` | `0xd7cb68fd22065d935a9faa7a4e0e4a85de12681ecb471ea0ecf7ca1717eb72d2` | `55,570` | `0.206669825 gwei` | `0.000011484642175250` | +| Approve XAUt `0.007474` | `0x4d744ad77fe1184affe574833a5a9f8d03abae72f02a429ea46aaa2a53f247b1` | `36,460` | `0.224958854 gwei` | `0.000008201999816840` | +| `seedPool(68.763529, 68.763529)` | `0x1e4b9ddd6e19b35120be75986b3fb12e6f89fde19613bb1333cff2cb1ac4424a` | `79,844` | `0.227815022 gwei` | `0.000018189662616568` | +| Optimized `32`-loop proof | `0x34bdf049c864e250aaafcf5164560b63ac74364412db9d916ff6042d57b87da1` | `570,625` | `0.236918232 gwei` | `0.000135191466135000` | + +Total execution gas cost: + +```text +0.000178752344819633 ETH +``` + +### Proof Sizing + +The optimized proof used: + +```text +debt per loop: 0.593130 USDC +loops: 32 +total debt cycled: 18.980160 USDC +total cWUSDC input: 19.183519 cWUSDC +XAUt collateral/loop: 0.000230 XAUt +total XAUt collateral: 0.007360 XAUt +``` + +The dry run passed before broadcast. + +### Final State + +Final deployer wallet and vault state: + +```text +deployer ETH: 0.013913792667039243 +deployer cWUSDC: 70,390,560.771007 +deployer USDC: 0 +deployer XAUt: 0.007474 + +vault pool cWUSDC: 85.883499 +vault pool USDC: 85.763529 +vault lender USDC: 5.000000 +vault USDC token balance: 90.763529 +``` + +The vault now has: + +```text +cWUSDC surplus over pool USDC: 0.119970 +``` + +That surplus is expected from the current proof-vault design because round-trip loss is retained in the pool. This proves solvency and USDC conservation, but it confirms the next production improvement remains automatic cWUSDC surplus neutralization / peg maintenance. + +### Updated Capacity After Optimization + +Using pool USDC `85.763529` and the same strict one-way `<1%` sizing rule: + +```text +max strict debt per loop: ~0.593130 USDC +strict cWUSDC input/loop: ~0.599061 cWUSDC +32-loop strict batch: ~19.169962 cWUSDC target capacity +``` + +The live proof cycled `19.183519 cWUSDC`, matching the expected range and remaining inside the vault's `<1%` round-trip loss guard. + +## Loop/Round Optimization Before Balance Top-Up + +Generated: 2026-05-07 + +Current post-optimization constraints: + +```text +vault pool cWUSDC: 85.883499 +vault pool USDC: 85.763529 +vault lender USDC: 5.000000 +deployer cWUSDC: 70,390,560.771007 +deployer USDC: 0 +deployer XAUt: 0.007474 +deployer ETH: 0.013913792667039243 +XAUt allowance left: 0.000114 +cWUSDC allowance left: 12.052952 +``` + +No additional USDC is available in the wallet. The reusable resources are: + +```text +USDC rail inside vault +5 USDC lender bucket +0.007474 XAUt collateral, returned after each proof transaction +large wallet cWUSDC +ETH gas, preserving a 0.002 ETH reserve +``` + +### Hard Limits + +The current proof vault has three important loop limits: + +```text +1. runProof(...) supports max 32 loops per transaction. +2. debtUsdcPerLoop cannot exceed lenderUsdcAvailable = 5 USDC. +3. XAUt collateral must cover debt * loops for that transaction. +``` + +With current XAUt balance: + +| Debt per loop | Max loops per tx from XAUt | Total debt per tx | +|---:|---:|---:| +| `0.593130 USDC` | `32` | `18.980160 USDC` | +| `1.000000 USDC` | `19` | `19.000000 USDC` | +| `2.000000 USDC` | `9` | `18.000000 USDC` | +| `3.000000 USDC` | `6` | `18.000000 USDC` | +| `3.750000 USDC` | `5` | `18.750000 USDC` | +| `4.000000 USDC` | `4` | `16.000000 USDC` | +| `5.000000 USDC` | `3` | `15.000000 USDC` | + +The `5 USDC x 3 loops` schedule processes the most cWUSDC per unit of gas because it uses the full lender bucket with a small loop count. + +### Peg-Drift-Bounded Schedule + +The current vault already has cWUSDC surplus from completed proof loops: + +```text +current surplus: 0.119970 cWUSDC +1% surplus cap vs USDC reserve: ~0.857635 cWUSDC +remaining surplus headroom: ~0.737665 cWUSDC +``` + +If we want the reserve-implied pool ratio to stay within roughly `1%`, stop before the surplus crosses `0.857635`. + +Best peg-bounded schedule: + +```text +debt per loop: 5.000000 USDC +loops per round: 3 +rounds: 8 +total loops: 24 +total debt cycled: 120.000000 USDC +gross cWUSDC in: ~128.508415 +cWUSDC loss: ~0.725162 +ending surplus: ~0.845132 +surplus / USDC: ~0.985421% +``` + +The ninth round would cross the 1% reserve-surplus line: + +```text +rounds: 9 +gross cWUSDC in: ~144.648074 +cWUSDC loss: ~0.816237 +ending surplus: ~0.936207 +surplus / USDC: ~1.091614% +``` + +Therefore the best current no-top-up, peg-bounded execution is: + +```text +8 rounds of runProof(debt=5 USDC, loops=3) +then stop +``` + +This requires a fresh XAUt approval and more cWUSDC allowance, but no balance top-up. + +### Gas-Bounded Maximum Throughput + +If the goal is to process the most cWUSDC before needing ETH top-up, regardless of reserve-ratio drift, the same `5 USDC x 3 loops` shape remains best. + +Estimated outcomes while preserving `0.002 ETH`: + +| Gas assumption per 3-loop tx | Rounds possible | Gross cWUSDC in | cWUSDC loss retained | Ending surplus | +|---:|---:|---:|---:|---:| +| `112,400 gas` model | `466` | `~9,617.986747` | `~54.272875` | `~54.392845` | +| `150,000 gas` conservative | `349` | `~6,744.063220` | `~38.055819` | `~38.175789` | +| `180,000 gas` conservative | `291` | `~5,445.173572` | `~30.726394` | `~30.846364` | +| `200,000 gas` conservative | `262` | `~4,824.823928` | `~27.225856` | `~27.345826` | +| `250,000 gas` conservative | `209` | `~3,738.799664` | `~21.097573` | `~21.217543` | +| `300,000 gas` conservative | `174` | `~3,054.074265` | `~17.233761` | `~17.353731` | + +This gas-bounded path is not a public-peg path. It is an accounting-throughput path. It would conserve USDC, but the current vault would keep accumulating cWUSDC surplus until an automatic maintenance action exists. + +### Recommended Execution Policy + +Use this hierarchy: + +```text +1. If preserving public reserve-implied peg is required: + run at most 8 rounds of 5 USDC x 3 loops, then stop. + +2. If proving accounting throughput is acceptable: + run 5 USDC x 3 loops in batches, but label the result as closed-loop accounting throughput. + +3. If processing materially more than ~128 cWUSDC while preserving peg is required: + deploy the maintained Engine X vault first. +``` + +Required next contract improvement: + +```text +auto-neutralize cWUSDC surplus after each round +or sweep surplus to a neutral treasury/burn/lock bucket +or track a separate accounting reserve so public pool reserves return to 1:1 +``` + +Without that maintenance step, the safe current recommendation is: + +```text +approve enough cWUSDC + XAUt +dry-run 5 USDC x 3 loops +run up to 8 rounds +stop and re-read reserves +``` + +## Maintained Engine X Vault Deployment + +Executed: 2026-05-07 + +New maintained vault: + +```text +DBISEngineXMaintainedProofVault: 0x91E990E527c9ABD9e54F98b6Ba6BF50A2f9624D6 +owner: 0x4A666F96fC8764181194447A7dFdb7d471b301C8 +surplusReceiver: 0x4A666F96fC8764181194447A7dFdb7d471b301C8 +maxSurplusDust: 0 +``` + +Contract behavior: + +```text +1. Run the normal cWUSDC -> USDC -> cWUSDC proof loop. +2. Keep pool USDC unchanged. +3. Compute cWUSDC surplus after each loop. +4. Remove all surplus from pool reserves. +5. Transfer neutralized surplus to surplusReceiver. +6. End each loop with pool cWUSDC == pool USDC. +``` + +This makes the vault a maintained accounting proof. Surplus is not burned; it is separated from pool reserves and emitted through `SurplusNeutralized`. + +### Deployment And Migration Transactions + +| Step | Tx hash | +|---|---| +| Deploy maintained vault | `0x9d008e3ee5dfc2df3f2602aade15d144ec5f738153dab106f081ea0b9fdef6d6` | +| Withdraw old vault cWUSDC | `0x8f190a3f3da573503e81c4239a52420370c6caef88d460a931f81cc3218a68b5` | +| Withdraw old vault USDC | `0x7d77ee17029361042c269545c960779df1ca9a74f336eda171f5b7002adf8c10` | +| Approve cWUSDC for new seed | `0x60651f2f9589cfd0b29808eb946e605fdcd63087c066fc6d6dff0c1ac8c80ca7` | +| Approve USDC for new seed/lender | `0x7098b68951bfffbea7f163c1fc6f007845da9248d984a571dd9fb81e2e3c1173` | +| Seed maintained vault `85.763529 / 85.763529` | `0x13da64910309c73f26911cfcaa8f5abf0bb9b63ca9f067fd1f834ac09a5a1e7c` | +| Fund maintained lender `5.000000 USDC` | `0x79cbc71df551744e3a55a61d68243a78a0ab7004357f0a639054f4a1c503aa1b` | +| Approve cWUSDC proof input | `0xe528266a933e320de77fc65e8b67661d1fd52aebf90f4e600defa1236b032d80` | +| Approve XAUt proof collateral | `0x7f31e5d1876e992a5ce473469884293c669ccbfc7ba6686413ae3a3cada124b9` | + +Old proof vault after migration: + +```text +old vault cWUSDC: 0 +old vault USDC: 0 +old vault XAUt: 0 +``` + +### Maintained Proof Transaction + +Dry run passed, then one maintained proof was broadcast: + +```text +tx: 0xcf9b1876d988c0a59ce4e11c59faa0cb563256d84a070fbe85604ad0a48874fd +debt per loop: 5.000000 USDC +loops: 3 +total debt: 15.000000 USDC +total cWUSDC: 15.976569 cWUSDC +neutralized: 0.090156 cWUSDC +gas used: 180,724 +``` + +Final maintained vault state: + +```text +pool cWUSDC: 85.763529 +pool USDC: 85.763529 +lender USDC: 5.000000 +currentSurplusCwusdc: 0 +totalNeutralizedCwusdc: 0.090156 +vault cWUSDC token bal: 85.763529 +vault USDC token bal: 90.763529 +``` + +Final deployer balances relevant to Engine X: + +```text +ETH: 0.013562022271250384 +cWUSDC: 70,390,560.890977 +USDC: 0 +XAUt: 0.007474 +``` + +### Updated Operating Mode + +The maintained vault fixes the previous drift problem: + +```text +Before: cWUSDC surplus accumulated inside pool reserves. +After: cWUSDC surplus is removed each loop and pool reserves return to 1:1. +``` + +The current best loop shape remains: + +```text +debt per loop: 5 USDC +loops per tx: 3 +``` + +Because the maintained vault neutralizes surplus after every loop, the 8-round reserve-drift stop is no longer required. The practical limits are now: + +```text +ETH gas budget +XAUt allowance / balance +cWUSDC allowance / balance +5 USDC lender bucket +``` diff --git a/reports/status/dbis-engine-x-mainnet-001-005-loop-proof-20260506.md b/reports/status/dbis-engine-x-mainnet-001-005-loop-proof-20260506.md new file mode 100644 index 00000000..65748e3e --- /dev/null +++ b/reports/status/dbis-engine-x-mainnet-001-005-loop-proof-20260506.md @@ -0,0 +1,91 @@ +# DBIS Engine X Mainnet 0.01 / 0.05 USD Loop Proof + +Generated: 2026-05-06 + +## Summary + +Ethereum Mainnet proof completed with a dedicated Engine X proof vault. The proof uses wallet `cWUSDC`, XAUt collateral, and a dedicated internal `17 cWUSDC / 17 USDC` proof pool. Existing public Uniswap/DODO pools were not mutated. + +The loop shape is: + +```text +escrow XAUt collateral +borrow/deposit USDC inside the proof vault +swap wallet cWUSDC -> USDC to repay the borrow +swap the released/deposited USDC back into cWUSDC +return XAUt collateral +close +``` + +The final wallet cWUSDC reduction from the proof loops was `0.005801 cWUSDC`, which is `0.600812%` of the loop cWUSDC input and below the configured `1%` cap. + +## Live Contracts + +| Component | Address | +|---|---| +| DBIS Engine X proof vault | `0x9aA317dDccC2293d9F34dD9c837e24caF43CbfA3` | +| cWUSDC | `0x2de5F116bFcE3d0f922d9C8351e0c5Fc24b9284a` | +| USDC | `0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48` | +| XAUt | `0x68749665FF8D2d112Fa859AA293F07A622782F38` | + +Contract source: `smom-dbis-138/contracts/flash/DBISEngineXProofVault.sol` + +## Transactions + +| Action | Tx | +|---|---| +| Deploy proof vault | `0x177cc94329b35e93da2004d578c8f27ff02995bd244cd8651c0b243490f3e8cf` | +| Approve cWUSDC | `0x76b3e30a746c2fedce59ba242fb311d1791e9692dff1e328acabcd831a3ed81a` | +| Approve USDC | `0x193b9a124805304e12ab4c506314446d4041ae2ac3cfa09d6225d17cb106ad88` | +| Approve XAUt | `0x163d626761b44a4b02aa99fb117bbd6c503573399f48b43dec6b1770ba3ef931` | +| Seed proof pool, `17 cWUSDC / 17 USDC` | `0xce0e262f99030ffba90d6659c30a8147a5f888fd7570a05bfa5a4743b118e39b` | +| Fund lender bucket, `5 USDC` | `0x6655f95343adca03d3b8289b91d570f9ca5be9526c8a9590968428c00feba714` | +| Batch proof, all 8 scenarios | `0xda991e4128379100d2159fe8e67dd412816ef76a583451c6cb610d6e3c67d471` | + +## Proof Results + +All amounts are 6-decimal raw-token compatible. + +| Scenario | Total USDC debt proved | cWUSDC in | cWUSDC returned | Net cWUSDC loss | Loss % | +|---|---:|---:|---:|---:|---:| +| `0.01`, single | `0.010000` | `0.010036` | `0.009975` | `0.000061` | `0.607812%` | +| `0.01`, 3 loops | `0.030000` | `0.030111` | `0.029926` | `0.000185` | `0.614393%` | +| `0.01`, 5 loops | `0.050000` | `0.050185` | `0.049880` | `0.000305` | `0.607751%` | +| `0.01`, 7 loops | `0.070000` | `0.070259` | `0.069832` | `0.000427` | `0.607751%` | +| `0.05`, single | `0.050000` | `0.050302` | `0.050000` | `0.000302` | `0.600374%` | +| `0.05`, 3 loops | `0.150000` | `0.150911` | `0.150006` | `0.000905` | `0.599691%` | +| `0.05`, 5 loops | `0.250000` | `0.251535` | `0.250029` | `0.001506` | `0.598724%` | +| `0.05`, 7 loops | `0.350000` | `0.352187` | `0.350077` | `0.002110` | `0.599114%` | + +Aggregate: + +```text +Total cWUSDC in: 0.965526 +Total cWUSDC returned: 0.959725 +Net cWUSDC loss: 0.005801 +Aggregate loss: 0.600812% +``` + +## Final On-Chain State + +Proof vault: + +```text +poolCwusdcReserve: 17.005801 cWUSDC +poolUsdcReserve: 17.000000 USDC +lenderUsdcAvailable: 5.000000 USDC +minimum XAUt for 0.01: 0.000004 XAUt +minimum XAUt for 0.05: 0.000020 XAUt +``` + +Deployer wallet after proof: + +```text +ETH: 0.007651475572918235 +cWUSDC: 818,104.362346 +USDC: 0.326379 +XAUt: 0.003256 +``` + +XAUt collateral was returned to the wallet. USDC was reduced by the `17 USDC` pool seed and `5 USDC` lender funding. The proof pool retained only the cWUSDC round-trip loss as intended. + diff --git a/reports/status/mainnet-xaut-secured-loop-components-20260506T214708Z.json b/reports/status/mainnet-xaut-secured-loop-components-20260506T214708Z.json new file mode 100644 index 00000000..f4c9c776 --- /dev/null +++ b/reports/status/mainnet-xaut-secured-loop-components-20260506T214708Z.json @@ -0,0 +1,511 @@ +{ + "addresses": { + "USDC": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", + "XAUt": "0x68749665FF8D2d112Fa859AA293F07A622782F38", + "aaveDataProvider": "0x0a16f2FCC0D44FaE41cc54e079281D84A363bECD", + "aavePool": "0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2", + "aaveProvider": "0x2f39d218133AFaB8F2B819B1066c7E434Ad94E9e", + "cWUSDC": "0x2de5F116bFcE3d0f922d9C8351e0c5Fc24b9284a", + "cWUSDT": "0xaF5017d0163ecb99D9B5D94e3b4D7b09Af44D8AE", + "cWXAUT": "0xACE1DBF857549a11aF1322e1f91F2F64b029c906", + "deployerOrHolder": "0x4A666F96fC8764181194447A7dFdb7d471b301C8" + }, + "component": { + "name": "DBIS Engine X", + "purpose": "Ethereum Mainnet XAUt/USD secured-loop proof engine. XAUt is interpreted as XAU and USDC/cWUSDC as USD.", + "repo": "https://gitea.d-bis.org/DBIS/ENGINE-X.git", + "repoBindingStatus": "declared_not_cloned" + }, + "constraints": { + "borrowCeiling": "D <= F * P * L", + "flashRepayment": "S >= F * (1 + g)", + "healthFactor": "HF = ((F * P * LT_XAUt) + (D * LT_USDC)) / D", + "primaryProofVenue": "Uniswap", + "safeDebt": "D <= (F * P * LT_XAUt) / (HF_target - LT_USDC)", + "takeoutCapacity": "F <= cWUSDC_value / (P_after_slippage * (1 + g))", + "uniswapRepayment": "XAUt out must cover flash principal plus Uniswap fee", + "uniswapRoute": "cWUSDC -> cWXAUT -> XAUt" + }, + "generatedAt": "2026-05-06T21:48:04.307306+00:00", + "interpretation": { + "USDC": "USD cash/debt/collateral value", + "XAUt": "XAU commodity/collateral value", + "cWUSDC": "USD-denominated owned asset value for this model" + }, + "mainnetProof": { + "aave": { + "dataProvider": "0x0a16f2FCC0D44FaE41cc54e079281D84A363bECD", + "finding": "XAUt is collateral-enabled but live LTV is zero, so live Aave cannot originate the USDC debt leg from XAUt collateral.", + "pool": "0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2", + "provider": "0x2f39d218133AFaB8F2B819B1066c7E434Ad94E9e", + "reserves": { + "USDC": { + "aToken": "0x98C23E9d8f34FEFb1B7BD6a91B7FF122F4e16F5c", + "asset": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", + "availableLiquidityRaw": "166807676484607", + "availableLiquidityUnits": "166807676.484607", + "borrowCapWholeTokens": "4500000000", + "borrowingEnabled": true, + "decimals": 6, + "isActive": true, + "isFrozen": false, + "liquidationBonusBps": 10450, + "liquidationThresholdBps": 7800, + "ltvBps": 7500, + "reserveFactorBps": 1000, + "stableBorrowRateEnabled": false, + "stableDebtToken": "0x0000000000000000000000000000000000000000", + "supplyCapWholeTokens": "5000000000", + "usageAsCollateralEnabled": true, + "variableDebtToken": "0x72E95b8931767C79bA4EeE721354d6E99a61D004" + }, + "XAUt": { + "aToken": "0x8A2b6f94Ff3A89a03E8c02Ee92b55aF90c9454A2", + "asset": "0x68749665FF8D2d112Fa859AA293F07A622782F38", + "availableLiquidityRaw": "15988185513", + "availableLiquidityUnits": "15988.185513", + "borrowCapWholeTokens": "1", + "borrowingEnabled": false, + "decimals": 6, + "isActive": true, + "isFrozen": false, + "liquidationBonusBps": 10600, + "liquidationThresholdBps": 7500, + "ltvBps": 0, + "reserveFactorBps": 2000, + "stableBorrowRateEnabled": false, + "stableDebtToken": "0x0000000000000000000000000000000000000000", + "supplyCapWholeTokens": "25000", + "usageAsCollateralEnabled": true, + "variableDebtToken": "0xa665bB258D2a732C170dFD505924214c0b1AC74F" + } + } + }, + "routes": { + "cWrappedXauPools": { + "cwusdcCwxautUniv2": { + "pair": "0xFfa378CC7c4FFEfa2793952Ef0dF8763ca8fE9B2", + "reserve0Raw": "12927855752", + "reserve0Units": "12927.855752", + "reserve1Raw": "23271", + "reserve1Units": "0.023271", + "status": "ok", + "token0": { + "address": "0x2de5F116bFcE3d0f922d9C8351e0c5Fc24b9284a", + "decimals": 6, + "symbol": "\"cWUSDC\"" + }, + "token1": { + "address": "0xACE1DBF857549a11aF1322e1f91F2F64b029c906", + "decimals": 6, + "symbol": "\"cWXAUT\"" + } + }, + "cwusdtCwxautUniv2": { + "pair": "0x3A1dAbab7B375918A36480e7256b29c9200e808A", + "reserve0Raw": "300000", + "reserve0Units": "0.3", + "reserve1Raw": "1000000000", + "reserve1Units": "1000", + "status": "ok", + "token0": { + "address": "0xACE1DBF857549a11aF1322e1f91F2F64b029c906", + "decimals": 6, + "symbol": "\"cWXAUT\"" + }, + "token1": { + "address": "0xaF5017d0163ecb99D9B5D94e3b4D7b09Af44D8AE", + "decimals": 6, + "symbol": "\"cWUSDT\"" + } + }, + "cwxautUsdcUniv2": { + "pair": "0x0000000000000000000000000000000000000000", + "status": "missing" + }, + "cwxautXautUniv2": { + "pair": "0xEd1E7d67608F2f56E0E8C2c46E42d29C34e25eb0", + "reserve0Raw": "15", + "reserve0Units": "0.000015", + "reserve1Raw": "276729", + "reserve1Units": "0.276729", + "status": "ok", + "token0": { + "address": "0x68749665FF8D2d112Fa859AA293F07A622782F38", + "decimals": 6, + "symbol": "\"XAUt\"" + }, + "token1": { + "address": "0xACE1DBF857549a11aF1322e1f91F2F64b029c906", + "decimals": 6, + "symbol": "\"cWXAUT\"" + } + } + }, + "cwxautUsdcDodo": { + "baseBalanceRaw": "831", + "baseBalanceUnits": "0.000831", + "baseReserveRaw": "831", + "baseReserveUnits": "0.000831", + "baseToken": { + "address": "0xACE1DBF857549a11aF1322e1f91F2F64b029c906", + "decimals": 6, + "symbol": "\"cWXAUT\"" + }, + "pool": "0x1D51a38C924382287d770AbB61deb9C39ACa96E9", + "quoteBalanceRaw": "2659200", + "quoteBalanceUnits": "2.6592", + "quoteReserveRaw": "2659200", + "quoteReserveUnits": "2.6592", + "quoteToken": { + "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", + "decimals": 6, + "symbol": "\"USDC\"" + }, + "status": "ok" + }, + "internalUsdMeshUniv2": { + "pair": "0x422608c5dDff909675ac2C5F872fD42f16B9287A", + "reserve0Raw": "9900803423131", + "reserve0Units": "9900803.423131", + "reserve1Raw": "9900803423129", + "reserve1Units": "9900803.423129", + "status": "ok", + "token0": { + "address": "0x2de5F116bFcE3d0f922d9C8351e0c5Fc24b9284a", + "decimals": 6, + "symbol": "\"cWUSDC\"" + }, + "token1": { + "address": "0xaF5017d0163ecb99D9B5D94e3b4D7b09Af44D8AE", + "decimals": 6, + "symbol": "\"cWUSDT\"" + } + }, + "officialXautPools": { + "xautUsdcUniv2": { + "pair": "0xf2ED762E4B5ea630A0a390Acd366597383cbF29A", + "reserve0Raw": "106", + "reserve0Units": "0.000106", + "reserve1Raw": "510500", + "reserve1Units": "0.5105", + "status": "ok", + "token0": { + "address": "0x68749665FF8D2d112Fa859AA293F07A622782F38", + "decimals": 6, + "symbol": "\"XAUt\"" + }, + "token1": { + "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", + "decimals": 6, + "symbol": "\"USDC\"" + } + }, + "xautUsdcUniv3": [ + { + "exists": true, + "fee": 100, + "liquidity": "0", + "pool": "0xCD1FB6E44F73Edb20A0Cb7A23495888230D8993E" + }, + { + "exists": true, + "fee": 500, + "liquidity": "202332554", + "pool": "0x425e00Cf56B45A55756E655f6af536003d793f2E" + }, + { + "exists": true, + "fee": 3000, + "liquidity": "21130358552", + "pool": "0x841ea2475A989eECCD27Fe39967c19CB097357A3" + }, + { + "exists": true, + "fee": 10000, + "liquidity": "419665832", + "pool": "0x16439c7007b9267cf1557f50F37497fCAa69A0dC" + } + ], + "xautWethUniv2": { + "pair": "0x589eA310F2500f6859d2619518fd1b95bB1bB0B1", + "reserve0Raw": "552", + "reserve0Units": "0.000552", + "reserve1Raw": "1033701040841919", + "reserve1Units": "0.00103370104", + "status": "ok", + "token0": { + "address": "0x68749665FF8D2d112Fa859AA293F07A622782F38", + "decimals": 6, + "symbol": "\"XAUt\"" + }, + "token1": { + "address": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", + "decimals": 18, + "symbol": "\"WETH\"" + } + }, + "xautWethUniv3": [ + { + "exists": true, + "fee": 100, + "liquidity": "0", + "pool": "0x179B43C8C6299D3993aDfC5068a9D19037dAE7FA" + }, + { + "exists": false, + "fee": 500, + "pool": "0x0000000000000000000000000000000000000000" + }, + { + "exists": true, + "fee": 3000, + "liquidity": "201017665360273", + "pool": "0xC5C7c21F4e60770CA5991a8832127A40f5236f73" + }, + { + "exists": true, + "fee": 10000, + "liquidity": "16791344144700", + "pool": "0x3E04d683f7187BC0293e05006203AcCB29311767" + } + ] + }, + "officialXautTakeoutRoute": { + "reason": "No repo-approved on-chain redemption/venue proof currently converts cWXAUT into official Mainnet XAUt inside the same transaction.", + "required": "A minOut-verifiable cWUSDC -> cWXAUT -> XAUt route or a compliant redemption adapter callable in the flash callback.", + "status": "proof_gated" + } + }, + "tokens": { + "USDC": { + "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", + "decimals": 6, + "holderBalanceRaw": "1", + "holderBalanceUnits": "0.000001", + "symbol": "\"USDC\"" + }, + "XAUt": { + "address": "0x68749665FF8D2d112Fa859AA293F07A622782F38", + "decimals": 6, + "holderBalanceRaw": "173", + "holderBalanceUnits": "0.000173", + "symbol": "\"XAUt\"" + }, + "cWUSDC": { + "address": "0x2de5F116bFcE3d0f922d9C8351e0c5Fc24b9284a", + "decimals": 6, + "holderBalanceRaw": "818121368147", + "holderBalanceUnits": "818121.368147", + "symbol": "\"cWUSDC\"" + }, + "cWUSDT": { + "address": "0xaF5017d0163ecb99D9B5D94e3b4D7b09Af44D8AE", + "decimals": 6, + "holderBalanceRaw": "8523829088635", + "holderBalanceUnits": "8523829.088635", + "symbol": "\"cWUSDT\"" + }, + "cWXAUT": { + "address": "0xACE1DBF857549a11aF1322e1f91F2F64b029c906", + "decimals": 6, + "holderBalanceRaw": "0", + "holderBalanceUnits": "0", + "symbol": "\"cWXAUT\"" + } + } + }, + "mode": "read_only_mainnet_proof_components", + "operatorCommands": { + "componentProof": "pnpm mainnet-xaut:loop-components", + "engineXComponentProof": "pnpm dbis-engine-x:component-proof", + "engineXRepo": "git ls-remote https://gitea.d-bis.org/DBIS/ENGINE-X.git", + "fullLoopNext": "mainnet fork first: build DBIS Engine X around Uniswap route/flash proof; Aave is informational until XAUt LTV is non-zero.", + "pyCompile": "python3 -m py_compile scripts/verify/prove-mainnet-xaut-secured-loop-components.py", + "shellSyntax": "bash -n scripts/verify/prove-mainnet-xaut-secured-loop-components.sh" + }, + "readiness": { + "broadcastSafe": false, + "forkMockLoop": "ready_to_build_with_uniswap_primary_route", + "liveMainnetBorrowLeg": "not_used_uniswap_primary_aave_xaut_ltv_zero", + "primaryProofVenue": "uniswap", + "swapTakeoutLeg": "uniswap_cwusdc_cwxaut_xaut_route_ready" + }, + "sizingModel": { + "forkMockCase": { + "borrowLegStatus": "model_ready", + "case": "fork_or_mock_secured_credit", + "healthFactorAtSafeDebt": "1.933846", + "maxFlashPrincipalXautBySwapAndLiquidity": "156.800894119962", + "maxUsdcDebtByHealthFactor": "1291940.9815", + "maxUsdcDebtByLtv": "526250.626464", + "safeUsdcDebt": "526250.626464", + "xautLiquidationThresholdBps": 7500, + "xautLtvBps": 6500 + }, + "liveAaveCase": { + "borrowLegStatus": "blocked_zero_ltv", + "case": "live_aave_mainnet", + "healthFactorAtSafeDebt": null, + "maxFlashPrincipalXautBySwapAndLiquidity": "156.800894119962", + "maxUsdcDebtByHealthFactor": "1291940.9815", + "maxUsdcDebtByLtv": "0", + "safeUsdcDebt": "0", + "xautLiquidationThresholdBps": 7500, + "xautLtvBps": 0 + }, + "swapTakeoutCapacity": { + "constraint": "F <= cWUSDC_value / (P_after_slippage * (1 + g))", + "maxXautFlashPrincipalRepayableByCwusdcRoute": "156.800894119962" + }, + "variables": { + "cwusdcValueUsd": "818121.368147", + "flashFeeBps": "5", + "hfTarget": "1.25", + "priceAfterSlippageUsdPerXaut": "5214.97352729", + "slippageBps": "100", + "usdcLiquidationThresholdBps": 7800, + "xautPriceUsd": "5163.34012603" + } + }, + "uniswapProofModel": { + "assumptions": { + "cwusdcUsdPerUnit": "1", + "cwxautToXautReference": "1:1 reference only unless cWXAUT/XAUt pair exists and quotes live", + "priceAfterSlippageUsdPerXaut": "5214.97352729", + "slippageBps": "100", + "uniswapV2FeeBps": 30, + "xautPriceUsd": "5163.34012603" + }, + "inputToken": "0x2de5F116bFcE3d0f922d9C8351e0c5Fc24b9284a", + "intermediateToken": "0xACE1DBF857549a11aF1322e1f91F2F64b029c906", + "mode": "uniswap_cwusdc_to_cwxaut_then_cwxaut_xaut_quote_pair", + "proofRoute": [ + "cWUSDC", + "cWXAUT", + "XAUt" + ], + "quotePairTarget": { + "base": "0xACE1DBF857549a11aF1322e1f91F2F64b029c906", + "pair": "0xEd1E7d67608F2f56E0E8C2c46E42d29C34e25eb0", + "quote": "0x68749665FF8D2d112Fa859AA293F07A622782F38", + "role": "official XAUt quote/takeout pair for cWXAUT", + "status": "ok" + }, + "rows": [ + { + "cwusdcInputRawPerLoop": "10000", + "cwusdcInputUnitsPerLoop": "0.01", + "cwxautOutRawPerLoop": "0", + "cwxautOutUnitsPerLoop": "0", + "cwxautOutUnitsTotal": "0", + "executableOnMainnet": true, + "loops": 1, + "perLoopUsdValue": "0.01", + "quotePairStatus": "ok", + "referenceSurplusCwxautVsRequiredXautUnits": "-0.000001917555", + "requiredOfficialXautUnitsTotal": "0.000001917555", + "totalUsdValue": "0.01" + }, + { + "cwusdcInputRawPerLoop": "10000", + "cwusdcInputUnitsPerLoop": "0.01", + "cwxautOutRawPerLoop": "0", + "cwxautOutUnitsPerLoop": "0", + "cwxautOutUnitsTotal": "0", + "executableOnMainnet": true, + "loops": 3, + "perLoopUsdValue": "0.01", + "quotePairStatus": "ok", + "referenceSurplusCwxautVsRequiredXautUnits": "-0.000005752665", + "requiredOfficialXautUnitsTotal": "0.000005752665", + "totalUsdValue": "0.03" + }, + { + "cwusdcInputRawPerLoop": "10000", + "cwusdcInputUnitsPerLoop": "0.01", + "cwxautOutRawPerLoop": "0", + "cwxautOutUnitsPerLoop": "0", + "cwxautOutUnitsTotal": "0", + "executableOnMainnet": true, + "loops": 5, + "perLoopUsdValue": "0.01", + "quotePairStatus": "ok", + "referenceSurplusCwxautVsRequiredXautUnits": "-0.000009587776", + "requiredOfficialXautUnitsTotal": "0.000009587776", + "totalUsdValue": "0.05" + }, + { + "cwusdcInputRawPerLoop": "10000", + "cwusdcInputUnitsPerLoop": "0.01", + "cwxautOutRawPerLoop": "0", + "cwxautOutUnitsPerLoop": "0", + "cwxautOutUnitsTotal": "0", + "executableOnMainnet": true, + "loops": 7, + "perLoopUsdValue": "0.01", + "quotePairStatus": "ok", + "referenceSurplusCwxautVsRequiredXautUnits": "-0.000013422886", + "requiredOfficialXautUnitsTotal": "0.000013422886", + "totalUsdValue": "0.07" + }, + { + "cwusdcInputRawPerLoop": "50000", + "cwusdcInputUnitsPerLoop": "0.05", + "cwxautOutRawPerLoop": "0", + "cwxautOutUnitsPerLoop": "0", + "cwxautOutUnitsTotal": "0", + "executableOnMainnet": true, + "loops": 1, + "perLoopUsdValue": "0.05", + "quotePairStatus": "ok", + "referenceSurplusCwxautVsRequiredXautUnits": "-0.000009587776", + "requiredOfficialXautUnitsTotal": "0.000009587776", + "totalUsdValue": "0.05" + }, + { + "cwusdcInputRawPerLoop": "50000", + "cwusdcInputUnitsPerLoop": "0.05", + "cwxautOutRawPerLoop": "0", + "cwxautOutUnitsPerLoop": "0", + "cwxautOutUnitsTotal": "0", + "executableOnMainnet": true, + "loops": 3, + "perLoopUsdValue": "0.05", + "quotePairStatus": "ok", + "referenceSurplusCwxautVsRequiredXautUnits": "-0.000028763329", + "requiredOfficialXautUnitsTotal": "0.000028763329", + "totalUsdValue": "0.15" + }, + { + "cwusdcInputRawPerLoop": "50000", + "cwusdcInputUnitsPerLoop": "0.05", + "cwxautOutRawPerLoop": "0", + "cwxautOutUnitsPerLoop": "0", + "cwxautOutUnitsTotal": "0", + "executableOnMainnet": true, + "loops": 5, + "perLoopUsdValue": "0.05", + "quotePairStatus": "ok", + "referenceSurplusCwxautVsRequiredXautUnits": "-0.000047938881", + "requiredOfficialXautUnitsTotal": "0.000047938881", + "totalUsdValue": "0.25" + }, + { + "cwusdcInputRawPerLoop": "50000", + "cwusdcInputUnitsPerLoop": "0.05", + "cwxautOutRawPerLoop": "0", + "cwxautOutUnitsPerLoop": "0", + "cwxautOutUnitsTotal": "0", + "executableOnMainnet": true, + "loops": 7, + "perLoopUsdValue": "0.05", + "quotePairStatus": "ok", + "referenceSurplusCwxautVsRequiredXautUnits": "-0.000067114434", + "requiredOfficialXautUnitsTotal": "0.000067114434", + "totalUsdValue": "0.35" + } + ], + "status": "quote_pair_ready" + } +} diff --git a/reports/status/mainnet-xaut-secured-loop-components-20260506T214708Z.md b/reports/status/mainnet-xaut-secured-loop-components-20260506T214708Z.md new file mode 100644 index 00000000..ec97bc1f --- /dev/null +++ b/reports/status/mainnet-xaut-secured-loop-components-20260506T214708Z.md @@ -0,0 +1,46 @@ +# DBIS Engine X Mainnet Proof Components + +Generated: `2026-05-06T21:48:04.307306+00:00` +Component repo: `https://gitea.d-bis.org/DBIS/ENGINE-X.git` + +## Verdict + +- Primary proof venue: `uniswap`. +- Aave XAUt borrow leg: `not_used_uniswap_primary_aave_xaut_ltv_zero`. +- Swap/takeout leg: `uniswap_cwusdc_cwxaut_xaut_route_ready`. +- Fork/mock loop: `ready_to_build_with_uniswap_primary_route`. + +## Banking Interpretation + +- `XAUt` is treated as `XAU` collateral/commodity value. +- `USDC` and `cWUSDC` are treated as `USD` value for this proof model. +- The active proof path uses Uniswap route/flash mechanics. Aave reserve data is retained as informational evidence only while XAUt LTV is zero. + +## Live Mainnet Proof + +- Aave Pool: `0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2` +- Aave DataProvider: `0x0a16f2FCC0D44FaE41cc54e079281D84A363bECD` +- XAUt LTV: `0` bps; liquidation threshold: `7500` bps; collateral enabled: `True`. +- USDC borrowing enabled: `True`; USDC liquidation threshold: `7800` bps. + +## Route Components + +- Internal USD mesh UniV2 cWUSDT/cWUSDC: `0x422608c5dDff909675ac2C5F872fD42f16B9287A` status `ok`. +- cWXAUT/USDC DODO PMM: `0x1D51a38C924382287d770AbB61deb9C39ACa96E9` status `ok`. +- Official XAUt/cWXAUT takeout route: `proof_gated`. +- cWXAUT/XAUt quote pair target: `0xEd1E7d67608F2f56E0E8C2c46E42d29C34e25eb0` status `ok`. + +## Engine X Uniswap Proof + +- Proof route: `cWUSDC -> cWXAUT -> XAUt`. +- Model status: `quote_pair_ready`. +- cWXAUT/XAUt quote pair role: `official XAUt quote/takeout pair for cWXAUT`. + +## Sizing + +- Aave informational max USDC debt: `0` because XAUt LTV is `0` bps. +- Fork/mock case max flash principal: `156.800894119962` XAUt; safe USDC debt: `526250.626464`. + +## Next Proof Step + +Build the next DBIS Engine X proof around the Uniswap cWUSDC -> cWXAUT -> XAUt route. Treat Aave as optional future secured-credit expansion until Mainnet XAUt LTV is non-zero. diff --git a/smom-dbis-138 b/smom-dbis-138 index 2ff84bd4..bb648368 160000 --- a/smom-dbis-138 +++ b/smom-dbis-138 @@ -1 +1 @@ -Subproject commit 2ff84bd4eedad8b88942c479ec9d7b14576501ec +Subproject commit bb64836886efb48b72596ef9c306c306aee5440d