@eco-incorp/sauce 0.99.0

package/sdk/dist/svm/venues/jupiter-lend-earn/index.js

@@ -0,0 +1,243 @@
+/**
+ * Jupiter Lend Earn — a lending-vault deposit/redeem (an Anchor program,
+ * NO on-chain IDL; the layout/ABI below is ground-truthed against the
+ * PUBLISHED Rust source — `Instadapp/fluid-solana-programs` @
+ * `626b177f235224bc5d074d39439cd2558f542886` (the commit Code4rena's
+ * `code-423n4/2026-02-jupiter-lend` audit scope points at after the sponsor
+ * had the code itself removed from the audit repo), `programs/lending/**`
+ * + `programs/liquidity/**` — NOT reverse-engineered. Two program deploys:
+ * Lending `jup3YeL8QhtSx1e253b2FDvsMNC87fDrgQZivbrndc9` (this family's
+ * `programId` — the CPI target) and the Liquidity layer it delegates all
+ * actual token accounting to, `jupeiUmn818Jg1ekPURTpr4mFo29p46vygyykFJ3wZC`
+ * (both confirmed live executable accounts on mainnet-beta, 2026-07-31).
+ *
+ * MECHANISM — a share-vault, not an AMM: `deposit(assets)` mints fTokens at
+ * the CURRENT `token_exchange_price` (a linear rate, assets-per-share scaled
+ * by `EXCHANGE_PRICES_PRECISION` = 1e12); `redeem(shares)` burns fTokens for
+ * assets at the same rate. There is no curvature and no fee parameter on
+ * either instruction — the rate IS the whole quote. This is why the plan
+ * calls for "quote = exact linear rate, monotone": `defaultRungs` is pinned
+ * at the framework floor (2, like `sanctum-stake-pool`'s identical affine
+ * case) — a straight line loses nothing to a coarser grid.
+ *
+ * LAYOUT — the `Lending` account (Anchor `#[account]`, sequential, NOT
+ * zero-copy — every field is a fixed-width primitive so offsets ARE fixed
+ * regardless): disc(8) + mint(32)@8 + f_token_mint(32)@40 + lending_id(u16)@72
+ * + decimals(u8)@74 + rewards_rate_model(32)@75 + liquidity_exchange_price(u64)@107
+ * + token_exchange_price(u64)@115 + last_update_timestamp(u64)@123 +
+ * token_reserves_liquidity(32)@131 + supply_position_on_liquidity(32)@163 +
+ * bump(u8)@195 — 196 bytes total. VERIFIED against three real mainnet
+ * `Lending` PDAs (USDC/USDT/wSOL markets; PDA = `["lending", mint,
+ * f_token_mint]`, `f_token_mint` itself `["f_token_mint", mint]`, both on
+ * this program): every one is EXACTLY 196 bytes with the Anchor discriminator
+ * `sha256("account:Lending")[0..8]` this file computes independently and
+ * both matched a live `getAccountInfo` byte-for-byte at the stated offsets
+ * (mint/f_token_mint/rewards_rate_model/token_reserves_liquidity/
+ * supply_position_on_liquidity all decoded to real, owner-correct accounts).
+ *
+ * ACCOUNTS the CPI needs beyond the `Lending` PDA itself — every one
+ * ground-truthed live, not guessed:
+ * - `lending_admin` = PDA(["lending_admin"], LENDING_PROGRAM) — ONE GLOBAL
+ *   singleton across every market (verified: a real, LENDING_PROGRAM-owned
+ *   account at the derived address).
+ * - `rate_model` = PDA(["rate_model", mint], LIQUIDITY_PROGRAM) — per-mint,
+ *   NOT constrained by a PDA seed in the Anchor `Operate` context itself
+ *   (`AccountLoader<RateModel>` with only a `has_one = mint` check), so this
+ *   file derives it the same way `set_rate_model`'s own seed constant
+ *   (`RATE_MODEL_SEED` in `liquidity/src/state/seeds.rs`) implies; verified
+ *   live for all three test markets (LIQUIDITY_PROGRAM-owned, 53-byte
+ *   `RateModel` accounts, `sha256("account:RateModel")[0..8]` discriminator
+ *   match).
+ * - `liquidity` = PDA(["liquidity"], LIQUIDITY_PROGRAM) — the SECOND global
+ *   singleton (the whole protocol's lock/authority state; verified live,
+ *   74 bytes, LIQUIDITY_PROGRAM-owned).
+ * - `supply_token_reserves_liquidity` = `lending.token_reserves_liquidity`
+ *   (a stored field — this file reads it rather than re-deriving; it
+ *   independently matches `PDA(["reserve", mint], LIQUIDITY_PROGRAM)` for
+ *   all three test markets, confirming the field and the seed agree).
+ * - `vault` = the `TokenReserve.vault` field (offset 40 within that
+ *   account, itself an Anchor zero-copy `#[account]` — disc(8) + mint(32)@8
+ *   + vault(32)@40 + ...). This file reads it via a second account load
+ *   rather than re-deriving the ATA (sidesteps classic-SPL-vs-Token-2022 ATA
+ *   derivation entirely — see the token-program gate below). Verified live:
+ *   the USDC market's vault is a real 165-byte SPL Token Account, owner
+ *   TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA, `authority` field equal to
+ *   the `liquidity` PDA above, holding real USDC (41.8M-ish at verification
+ *   time).
+ * - `token_program` — this adapter GATES to classic Tokenkeg only (Token-2022
+ *   extensions — transfer fees, gating hooks — are not modeled, matching
+ *   `sanctum-stake-pool`'s identical scope decision). Both mints (`mint` and
+ *   `f_token_mint`) are classified via the shared data-shape resolver
+ *   (`classifyMintProgram` / `parseMintExtensions`); a Token-2022 or
+ *   un-routable mint SELF-DROPS this market with a thrown error (the
+ *   graceful-drop signal the SvmRoute orchestrator catches).
+ *
+ * DISCOVERY — `Lending` stores BOTH mints at fixed offsets (mint@8,
+ * f_token_mint@40) with a fixed 196-byte size, so it discovers exactly like
+ * a two-mint AMM pool (see `SVM_FAMILY_FILTERS['jupiter-lend-earn']`) —
+ * no `fixedMint` special-case needed, unlike `sanctum-stake-pool`.
+ *
+ * QUOTE MATH — ground-truthed via `simulateTransaction` (sigVerify:false,
+ * `replaceRecentBlockhash:true` — nothing submitted for real) against the
+ * REAL deployed program on REAL mainnet state, 2026-07-31, USDC market, a
+ * real depositor wallet (`9936VF...cdL3QK`, a top fToken holder with a real
+ * USDC balance) as signer, at THREE sizes each direction:
+ *   deposit 1 USDC    -> predicted 948,989  shares, actual 948,988  (LogDeposit)
+ *   deposit 100 USDC  -> predicted 94,898,933 shares, actual 94,898,915
+ *   deposit 10,000 USDC -> predicted 9,489,893,345 shares, actual 9,489,891,642
+ *   redeem 1 share(*) -> predicted 1,053,752 assets, actual 1,053,752 (LogWithdraw) EXACT
+ *   redeem 100(*)     -> predicted 105,375,262 assets, actual 105,375,281
+ *   redeem 10,000(*)  -> predicted 10,537,526,225 assets, actual 10,537,528,114
+ * (* raw share units, not UI units — `redeem`'s CPI target is
+ * `global:redeem` / discriminator `[184,12,86,149,70,196,97,225]`, computed
+ * as `sha256("global:redeem")[0..8]` the SAME way this file independently
+ * re-derived `deposit`'s and `withdraw`'s documented discriminators and got
+ * an exact match — `redeem` itself is undocumented in the public CPI guide
+ * but shares the `Withdraw` account context verbatim per `lib.rs`/
+ * `utils/withdraw.rs`, confirmed live by the simulation above).
+ * Every deposit case matches within 18 raw units on a 9-10 digit number
+ * (<0.0002%); every redeem case is EQUAL or the offline estimate is LOWER
+ * than the real payout (the safe direction). Mechanism: `token_exchange_price`
+ * is monotonically non-decreasing and only refreshes when SOMEONE calls
+ * deposit/withdraw/redeem/rebalance — this file's on-chain fragment reads
+ * the STORED value live via `accountUint` (whatever the chain has AT COOK
+ * TIME, not a prepare-time snapshot), but the real CPI's OWN internal
+ * `update_rates` call recomputes a FRESH (>= stored) price inside the SAME
+ * instruction before minting/burning. `assets/price` (deposit's shares
+ * formula) is DECREASING in price, so the stale-vs-fresh gap makes deposit's
+ * offline estimate a THIN OVER-estimate (bounded by the measured <0.0002%
+ * above); `shares*price` (redeem's assets formula) is INCREASING in price,
+ * so the same gap makes redeem's estimate a THIN UNDER-estimate — the SAFE
+ * direction (never promises more than the venue delivers). Both are
+ * empirically tiny because the tested markets are touched every few minutes
+ * to under an hour (USDC last_update_timestamp was 17s stale at
+ * verification time, wSOL 429s, USDT 2,818s) — the codebase's existing
+ * tolerance for prepare/cook price drift elsewhere (CLMM tick movement,
+ * etc.) is the same shape of bound, not a new risk class.
+ *
+ * WITHDRAW CAP SELF-DROP — `redeem`'s underlying SPL transfer pulls straight
+ * from `vault`'s real balance; a redemption bigger than the vault can cover
+ * FAILS THE CPI (`simulateTransaction` reproduced this live: a redeem sized
+ * at ~4.7x the vault's real USDC balance reverted with
+ * `TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA`'s `Error: insufficient
+ * funds`, custom program error 0x1) — and a launched CPI failure aborts the
+ * WHOLE cook on SVM (no execution-time catch, see the consuming app SVM README's
+ * settled parity verdicts), so this MUST be a quote-time clamp, not a
+ * runtime guard. `emitQuoteCall`'s redeem branch reads `vault`'s LIVE SPL
+ * balance (the same `accountUint` pattern as every other family's reserve
+ * read) and saturates the predicted payout at 99.99% of it (a 1 bps margin
+ * against the residual "fresh-price-recompute" drift documented above,
+ * which is real but too small to eliminate without replicating the
+ * liquidity layer's own interest-accrual formula) — a monotone, concave
+ * (flat past the cap) curve, exactly the shape the merge election requires;
+ * past the cap this venue's marginal return is zero and the merge simply
+ * stops routing more here, never emitting a program that can revert this
+ * way.
+ *
+ * PROTOCOL LOCKDOWN SELF-DROP — `Liquidity.status` (offset 72, 1 byte) is a
+ * real, live "the whole protocol is paused" bool the Anchor program itself
+ * enforces (`Liquidity::is_locked()`, gates both `PreOperate`/`Operate` with
+ * `ErrorCodes::ProtocolLockdown`); this file reads it live in `emitSetup`
+ * (one more `accountUint`, shared by both directions since `liquidity` rides
+ * every deposit/redeem CPI already) and zeroes the quote when locked —
+ * cheap, and a genuine platform-level failure mode, not a speculative gate.
+ *
+ * DUST — a `deposit` whose `shares_minted` would compute to 0 reverts on
+ * -chain (`FTokenDepositInsignificant`); this file's helper already returns
+ * 0 for that input (floor division), matching the "returns 0 for dust"
+ * convention every other family's helper follows (a 0-quote slot is simply
+ * not elected by the merge, never emitted with a doomed CPI).
+ *
+ * CU — see `../budget.ts`'s `CU_FAMILIES['jupiter-lend-earn']` for the
+ * measurement + calibration method (real `simulateTransaction` CU: deposit
+ * ~56.3-57.5k, redeem ~66.3-67.7k raw CPI cost).
+ */
+import { address, getAddressDecoder, getAddressEncoder } from "@solana/kit";
+import { memoizedGetProgramDerivedAddress } from "../pda-memo.js";
+import { TOKEN_2022_PROGRAM_ID, classifyMintProgram } from "../../token-program.js";
+import { parseMintExtensions } from "../../token-extensions.js";
+const SLUG = "jupiter-lend-earn";
+export const JUPITER_LEND_EARN_PROGRAM_ID = address("jup3YeL8QhtSx1e253b2FDvsMNC87fDrgQZivbrndc9");
+/** The Liquidity layer every deposit/redeem CPI delegates real token accounting to. */
+export const JUPITER_LEND_LIQUIDITY_PROGRAM_ID = address("jupeiUmn818Jg1ekPURTpr4mFo29p46vygyykFJ3wZC");
+const TOKEN_PROGRAM = address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+// `Lending` account field offsets (after the 8-byte Anchor discriminator; see module header).
+const OFF_MINT = 8;
+const OFF_F_TOKEN_MINT = 40;
+const OFF_REWARDS_RATE_MODEL = 75;
+const OFF_TOKEN_RESERVES_LIQUIDITY = 131;
+const OFF_SUPPLY_POSITION_ON_LIQUIDITY = 163;
+export const LENDING_ACCOUNT_SIZE = 196;
+// `TokenReserve` (Liquidity layer, zero-copy) field offsets.
+const OFF_RESERVE_VAULT = 40;
+async function fetchJupiterLendEarnConfig(load, pool) {
+    const data = await load(pool);
+    if (data === null)
+        throw new Error(`jupiter-lend-earn Lending ${pool} account not found`);
+    if (data.length !== LENDING_ACCOUNT_SIZE) {
+        throw new Error(`jupiter-lend-earn Lending ${pool} has unexpected size ${data.length}, expected ${LENDING_ACCOUNT_SIZE}`);
+    }
+    const decoder = getAddressDecoder();
+    const mint = decoder.decode(data.subarray(OFF_MINT, OFF_MINT + 32));
+    const fTokenMint = decoder.decode(data.subarray(OFF_F_TOKEN_MINT, OFF_F_TOKEN_MINT + 32));
+    const rewardsRateModel = decoder.decode(data.subarray(OFF_REWARDS_RATE_MODEL, OFF_REWARDS_RATE_MODEL + 32));
+    const liquidityReserve = decoder.decode(data.subarray(OFF_TOKEN_RESERVES_LIQUIDITY, OFF_TOKEN_RESERVES_LIQUIDITY + 32));
+    const supplyPositionOnLiquidity = decoder.decode(data.subarray(OFF_SUPPLY_POSITION_ON_LIQUIDITY, OFF_SUPPLY_POSITION_ON_LIQUIDITY + 32));
+    // Tokenkeg-only (Token-2022 extensions — transfer fees, gating hooks — are
+    // not modeled, matching sanctum-stake-pool's identical scope decision), so
+    // detect a Token-2022 or un-routable mint via the shared data-shape resolver
+    // and SELF-DROP the market (the thrown error is the graceful-drop signal the
+    // SvmRoute orchestrator catches). The LEGACY path is byte-identical: a classic
+    // 82-byte mint classifies Tokenkeg with no extensions.
+    const _mints = [mint, fTokenMint];
+    const _mintDatas = await Promise.all(_mints.map((m) => load(m)));
+    for (let _i = 0; _i < _mints.length; _i++) {
+        const m = _mints[_i];
+        const mintData = _mintDatas[_i];
+        if (mintData === null)
+            continue; // an unreadable mint falls back to the legacy assumption
+        if (classifyMintProgram(m, mintData) === TOKEN_2022_PROGRAM_ID) {
+            throw new Error(`${SLUG}: dropping market ${pool} — mint ${m} is Token-2022 (this venue's swap is legacy-SPL only)`);
+        }
+        const { blocking } = parseMintExtensions(mintData);
+        if (blocking.length > 0) {
+            throw new Error(`${SLUG}: dropping market ${pool} — mint ${m} is un-routable: ${blocking.join("; ")}`);
+        }
+    }
+    const [reserveData, rateModel] = await Promise.all([
+        load(liquidityReserve),
+        deriveRateModel(mint),
+    ]);
+    if (reserveData === null)
+        throw new Error(`jupiter-lend-earn TokenReserve ${liquidityReserve} account not found`);
+    const vault = decoder.decode(reserveData.subarray(OFF_RESERVE_VAULT, OFF_RESERVE_VAULT + 32));
+    return {
+        venue: SLUG,
+        pool,
+        mint,
+        fTokenMint,
+        rewardsRateModel,
+        rateModel,
+        liquidityReserve,
+        supplyPositionOnLiquidity,
+        vault,
+        tokenProgram: TOKEN_PROGRAM,
+        direction: "deposit",
+    };
+}
+/** PDA(["rate_model", mint], LIQUIDITY_PROGRAM) — verified live for all three test markets. */
+async function deriveRateModel(mint) {
+    return memoizedGetProgramDerivedAddress(JUPITER_LEND_LIQUIDITY_PROGRAM_ID, [
+        Buffer.from("rate_model"),
+        Uint8Array.from(getAddressEncoder().encode(mint)),
+    ]);
+}
+function makeJupiterLendEarn() {
+    return {
+        slug: SLUG,
+        programId: JUPITER_LEND_EARN_PROGRAM_ID,
+        fetchPoolConfig: (load, pool) => fetchJupiterLendEarnConfig(load, pool),
+    };
+}
+export const jupiterLendEarn = makeJupiterLendEarn();
+//# sourceMappingURL=index.js.map

package/sdk/dist/svm/venues/jupiter-lend-earn/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/svm/venues/jupiter-lend-earn/index.ts"],"names":[],"mappings":"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"}

package/sdk/dist/svm/venues/juplend-amm/index.d.ts

@@ -0,0 +1,86 @@
+import type { Address } from "@solana/kit";
+import type { AccountLoader, PoolConfig, SwapUser, VenueAccount, VenueSwap } from "../types.js";
+declare const SLUG = "juplend-amm";
+export declare const JUPLEND_AMM_PROGRAM_ID: Address<"jupZ4m2GqUCJ5iueMfzQf8khFfH31d4XAQt3RzCT9Vd">;
+export declare const JUPLEND_LIQUIDITY_PROGRAM_ID: Address<"jupeiUmn818Jg1ekPURTpr4mFo29p46vygyykFJ3wZC">;
+export declare const JUPLEND_ORACLE_PROGRAM_ID: Address<"jupnw4B6Eqs7ft6rxpzYLJZYSnrpRgPcr589n5Kv4oc">;
+export declare const OFF_TOKEN_0 = 11;
+export declare const OFF_TOKEN_1 = 43;
+export declare const OFF_TOKEN_0_DECIMALS = 75;
+export declare const OFF_TOKEN_1_DECIMALS = 76;
+export declare const OFF_CENTER_PRICE = 109;
+export declare const OFF_SMART_COLLATERAL_ENABLED = 141;
+export declare const OFF_SMART_DEBT_ENABLED = 142;
+export declare const OFF_FEE = 143;
+export declare const OFF_CENTER_PRICE_ADDRESS = 166;
+export declare const OFF_IS_CENTER_PRICE_SHIFT_ACTIVE = 218;
+export declare const OFF_SWAP_AND_ARBITRAGE_PAUSED = 219;
+export declare const OFF_POSITION_AMOUNT = 73;
+export declare const OFF_POSITION_CEILING = 81;
+/** 1 raw-unit-per-raw-unit price scale (empirically confirmed — see module doc). */
+export declare const CENTER_PRICE_SCALE = 1000000000000000n;
+export declare const FEE_SCALE = 1000000n;
+export interface JuplendAmmPoolConfig extends PoolConfig {
+    venue: typeof SLUG;
+    /** true ⇒ token0 in / token1 out; false ⇒ token1 in / token0 out. */
+    swap0to1: boolean;
+    token0: Address;
+    token1: Address;
+    tokenProgram0: Address;
+    tokenProgram1: Address;
+    /** Liquidity-program TokenReserve PDAs (`["reserve", mint]`), one per mint. */
+    tokenReserve0: Address;
+    tokenReserve1: Address;
+    /** Each mint's shared-liquidity vault (read off its TokenReserve.vault field). */
+    vault0: Address;
+    vault1: Address;
+    /** `["rate_model", mint]` PDAs — carried through untouched for the swap CPI. */
+    rateModel0: Address;
+    rateModel1: Address;
+    /** `["liquidity"]` — one global singleton. */
+    liquidity: Address;
+    /** Whichever of supply/borrow position this Dex uses (see class doc). */
+    positionKind: "supply" | "borrow";
+    /** `["user_{supply,borrow}_position", mint, dex]` PDAs for BOTH mints. */
+    position0: Address;
+    position1: Address;
+    /** Dex.fee, ppm (1e6 scale). */
+    feePpm: bigint;
+}
+export declare const juplendAmm: {
+    slug: string;
+    kind: "constant-product";
+    programId: Address<"jupZ4m2GqUCJ5iueMfzQf8khFfH31d4XAQt3RzCT9Vd">;
+    /**
+     * Decode + shape-gate the Dex account, derive every PDA the swap CPI and
+     * the ladder need, and pick this Dex's position kind. Rejects: wrong
+     * size/discriminator, a paused Dex, an active center-price shift (see
+     * module doc), and a Dex with NEITHER smart_collateral nor smart_debt
+     * enabled (the real program's own swap can never succeed in that state —
+     * `_swapIn`'s routing-amount branch has no route, `DexNoSwapRoute`).
+     */
+    fetchPoolConfig(load: AccountLoader, pool: Address, swap0to1?: boolean): Promise<JuplendAmmPoolConfig>;
+    quoteAccounts(cfg: PoolConfig): VenueAccount[];
+    /**
+     * The full `swap_in` CPI (24 accounts — see module doc's account-list
+     * validation). `dex_supply_position_token_{0,1}` / `dex_borrow_position_token_{0,1}`
+     * carry the DEX's own program id as the Anchor "None" sentinel for
+     * whichever position kind this Dex does not use (proven correct: reaching
+     * real business logic past account resolution for both position kinds —
+     * see module doc). `amount_out_min` is the recipe-wide venue convention
+     * of 1 (the recipe's own outAta delta check owns the real floor).
+     */
+    buildSwap(cfg: PoolConfig, user: SwapUser, amountIn: bigint): VenueSwap;
+};
+/** sha256('global:swap_in')[0..8] — exported for buildSwapV2's prefix. */
+export declare const JUPLEND_SWAP_IN_DISCRIMINATOR: number[];
+/**
+ * The 24-account order `swap_in`/`swap_out` share (see dex.json's IDL).
+ * `make(role, addr, writable?)` builds one VenueAccount; `refFor` (default
+ * identity) lets buildSwapV2 slot-namespace the pool-owned refs while
+ * user-owned refs (owner/inAta/outAta) stay exactly as SwapUser gave them —
+ * the same shared-helper shape obric-v2's swapAccounts uses.
+ */
+export declare function juplendAmmSwapAccounts(c: JuplendAmmPoolConfig, user: SwapUser, make: (role: string, addr: Address, writable?: boolean) => VenueAccount, refFor?: (role: string) => string): VenueAccount[];
+export {};
+//# sourceMappingURL=index.d.ts.map

package/sdk/dist/svm/venues/juplend-amm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/svm/venues/juplend-amm/index.ts"],"names":[],"mappings":"AAmHA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAG3C,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,QAAQ,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAIhG,QAAA,MAAM,IAAI,gBAAgB,CAAC;AAE3B,eAAO,MAAM,sBAAsB,wDAAyD,CAAC;AAO7F,eAAO,MAAM,4BAA4B,wDAAoC,CAAC;AAC9E,eAAO,MAAM,yBAAyB,wDAAyD,CAAC;AAiBhG,eAAO,MAAM,WAAW,KAAK,CAAC;AAC9B,eAAO,MAAM,WAAW,KAAK,CAAC;AAC9B,eAAO,MAAM,oBAAoB,KAAK,CAAC;AACvC,eAAO,MAAM,oBAAoB,KAAK,CAAC;AACvC,eAAO,MAAM,gBAAgB,MAAM,CAAC;AACpC,eAAO,MAAM,4BAA4B,MAAM,CAAC;AAChD,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAC1C,eAAO,MAAM,OAAO,MAAM,CAAC;AAC3B,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAC5C,eAAO,MAAM,gCAAgC,MAAM,CAAC;AACpD,eAAO,MAAM,6BAA6B,MAAM,CAAC;AAGjD,eAAO,MAAM,mBAAmB,KAAK,CAAC;AACtC,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAEvC,oFAAoF;AACpF,eAAO,MAAM,kBAAkB,oBAAyB,CAAC;AACzD,eAAO,MAAM,SAAS,WAAa,CAAC;AAEpC,MAAM,WAAW,oBAAqB,SAAQ,UAAU;IACtD,KAAK,EAAE,OAAO,IAAI,CAAC;IACnB,qEAAqE;IACrE,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB,aAAa,EAAE,OAAO,CAAC;IACvB,aAAa,EAAE,OAAO,CAAC;IACvB,+EAA+E;IAC/E,aAAa,EAAE,OAAO,CAAC;IACvB,aAAa,EAAE,OAAO,CAAC;IACvB,kFAAkF;IAClF,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB,gFAAgF;IAChF,UAAU,EAAE,OAAO,CAAC;IACpB,UAAU,EAAE,OAAO,CAAC;IACpB,8CAA8C;IAC9C,SAAS,EAAE,OAAO,CAAC;IACnB,yEAAyE;IACzE,YAAY,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAClC,0EAA0E;IAC1E,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;IACnB,gCAAgC;IAChC,MAAM,EAAE,MAAM,CAAC;CAChB;AA8DD,eAAO,MAAM,UAAU;;;;IAKrB;;;;;;;OAOG;0BAEK,aAAa,QACb,OAAO,uBAEZ,OAAO,CAAC,oBAAoB,CAAC;uBAgHb,UAAU,GAAG,YAAY,EAAE;IAS9C;;;;;;;;OAQG;mBACY,UAAU,QAAQ,QAAQ,YAAY,MAAM,GAAG,SAAS;CAsBxE,CAAC;AAEF,0EAA0E;AAC1E,eAAO,MAAM,6BAA6B,UAAsC,CAAC;AAEjF;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,CAAC,EAAE,oBAAoB,EACvB,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,OAAO,KAAK,YAAY,EACvE,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAChC,YAAY,EAAE,CAmChB"}