@elizaos/agent 2.0.0-alpha.98 → 2.0.0-beta.1

package/packages/agent/src/api/wallet.js

@@ -1,513 +0,0 @@
-/**
- * Wallet key generation, address derivation, and balance/NFT fetching.
- * Uses Node crypto primitives (no viem/@solana/web3.js dependency).
- * Balance data from Alchemy/Ankr (EVM), NodeReal/QuickNode (BSC RPC),
- * and Helius (Solana) REST APIs.
- *
- * DEX price oracle logic lives in ./wallet-dex-prices.ts
- * EVM balance + NFT fetching lives in ./wallet-evm-balance.ts
- */
-import crypto from "node:crypto";
-import { logger } from "@elizaos/core";
-import { secp256k1 } from "@noble/curves/secp256k1.js";
-// ── Re-exports from extracted modules ─────────────────────────────────
-export { computeValueUsd, DEX_PRICE_TIMEOUT_MS, DEXPAPRIKA_CHAIN_MAP, DEXSCREENER_CHAIN_MAP, fetchDexPaprikaPrices, fetchDexPrices, fetchDexScreenerPrices, WRAPPED_NATIVE, } from "./wallet-dex-prices";
-export { DEFAULT_EVM_CHAINS, fetchEvmBalances, resolveEvmProviderKeys, } from "./wallet-evm-balance";
-// ── Constants ─────────────────────────────────────────────────────────
-const FETCH_TIMEOUT_MS = 15_000;
-export const MANAGED_EVM_ADDRESS_ENV_KEY = "ELIZA_MANAGED_EVM_ADDRESS";
-export const MANAGED_SOLANA_ADDRESS_ENV_KEY = "ELIZA_MANAGED_SOLANA_ADDRESS";
-// ── EVM key derivation (secp256k1 via @noble/curves + keccak-256) ─────
-function generateEvmPrivateKey() {
-    return `0x${crypto.randomBytes(32).toString("hex")}`;
-}
-export function deriveEvmAddress(privateKeyHex) {
-    const cleaned = privateKeyHex.startsWith("0x")
-        ? privateKeyHex.slice(2)
-        : privateKeyHex;
-    // Use @noble/curves — works in Node, Bun, and browsers.
-    // (Node's crypto.createECDH("secp256k1") fails in Bun due to BoringSSL.)
-    const pubKey = secp256k1.getPublicKey(Buffer.from(cleaned, "hex"), false); // uncompressed (65 bytes)
-    const pubNoPrefix = pubKey.subarray(1); // drop the 04 prefix
-    // Ethereum address = last 20 bytes of keccak-256(pubkey).
-    const hash = keccak256(pubNoPrefix);
-    return toChecksumAddress(`0x${hash.subarray(12).toString("hex")}`);
-}
-// ── Keccak-256 (minimal sponge implementation) ───────────────────────
-const RC = [
-    0x0000000000000001n,
-    0x0000000000008082n,
-    0x800000000000808an,
-    0x8000000080008000n,
-    0x000000000000808bn,
-    0x0000000080000001n,
-    0x8000000080008081n,
-    0x8000000000008009n,
-    0x000000000000008an,
-    0x0000000000000088n,
-    0x0000000080008009n,
-    0x000000008000000an,
-    0x000000008000808bn,
-    0x800000000000008bn,
-    0x8000000000008089n,
-    0x8000000000008003n,
-    0x8000000000008002n,
-    0x8000000000000080n,
-    0x000000000000800an,
-    0x800000008000000an,
-    0x8000000080008081n,
-    0x8000000000008080n,
-    0x0000000080000001n,
-    0x8000000080008008n,
-];
-const ROT = [
-    [0, 36, 3, 41, 18],
-    [1, 44, 10, 45, 2],
-    [62, 6, 43, 15, 61],
-    [28, 55, 25, 21, 56],
-    [27, 20, 39, 8, 14],
-];
-function keccak256(data) {
-    const rate = 136; // 1088 bits
-    const state = Array.from({ length: 5 }, () => Array.from({ length: 5 }, () => 0n));
-    // Keccak padding (0x01, NOT SHA-3's 0x06)
-    const q = rate - (data.length % rate);
-    const padded = Buffer.alloc(data.length + q);
-    padded.set(data);
-    padded[data.length] = 0x01;
-    padded[padded.length - 1] |= 0x80;
-    // Absorb
-    for (let off = 0; off < padded.length; off += rate) {
-        for (let i = 0; i < rate / 8; i++) {
-            let w = 0n;
-            for (let b = 0; b < 8; b++)
-                w |= BigInt(padded[off + i * 8 + b]) << BigInt(b * 8);
-            state[i % 5][Math.floor(i / 5)] ^= w;
-        }
-        keccakF1600(state);
-    }
-    // Squeeze (32 bytes)
-    const out = Buffer.alloc(32);
-    for (let i = 0; i < 4; i++) {
-        const v = state[i % 5][Math.floor(i / 5)];
-        for (let b = 0; b < 8; b++)
-            out[i * 8 + b] = Number((v >> BigInt(b * 8)) & 0xffn);
-    }
-    return out;
-}
-function keccakF1600(state) {
-    const M = (1n << 64n) - 1n;
-    const rot = (v, s) => s === 0 ? v : ((v << BigInt(s)) | (v >> BigInt(64 - s))) & M;
-    for (let round = 0; round < 24; round++) {
-        // theta
-        const c = [];
-        for (let x = 0; x < 5; x++)
-            c[x] =
-                state[x][0] ^ state[x][1] ^ state[x][2] ^ state[x][3] ^ state[x][4];
-        for (let x = 0; x < 5; x++) {
-            const d = c[(x + 4) % 5] ^ rot(c[(x + 1) % 5], 1);
-            for (let y = 0; y < 5; y++)
-                state[x][y] = (state[x][y] ^ d) & M;
-        }
-        // rho + pi
-        const b = Array.from({ length: 5 }, () => Array.from({ length: 5 }, () => 0n));
-        for (let x = 0; x < 5; x++)
-            for (let y = 0; y < 5; y++)
-                b[y][(2 * x + 3 * y) % 5] = rot(state[x][y], ROT[x][y]);
-        // chi
-        for (let x = 0; x < 5; x++)
-            for (let y = 0; y < 5; y++)
-                state[x][y] =
-                    (b[x][y] ^ (~b[(x + 1) % 5][y] & M & b[(x + 2) % 5][y])) & M;
-        // iota
-        state[0][0] = (state[0][0] ^ RC[round]) & M;
-    }
-}
-function toChecksumAddress(address) {
-    const addr = address.toLowerCase().replace("0x", "");
-    const hash = keccak256(Buffer.from(addr, "utf8")).toString("hex");
-    let out = "0x";
-    for (let i = 0; i < 40; i++)
-        out += Number.parseInt(hash[i], 16) >= 8 ? addr[i].toUpperCase() : addr[i];
-    return out;
-}
-// ── Solana key derivation (Ed25519 via Node crypto) ───────────────────
-function generateSolanaKeypair() {
-    const { privateKey, publicKey } = crypto.generateKeyPairSync("ed25519");
-    const privBytes = privateKey.export({ type: "pkcs8", format: "der" });
-    const pubBytes = publicKey.export({ type: "spki", format: "der" });
-    // Ed25519 PKCS8 DER: raw 32-byte seed at offset 16; SPKI DER: raw 32-byte pubkey at offset 12
-    const seed = privBytes.subarray(16, 48);
-    const pubRaw = pubBytes.subarray(12, 44);
-    // Solana secret key = seed(32) + pubkey(32)
-    return {
-        privateKey: base58Encode(Buffer.concat([seed, pubRaw])),
-        publicKey: base58Encode(pubRaw),
-    };
-}
-export function deriveSolanaAddress(privateKeyString) {
-    const secretBytes = decodeSolanaPrivateKey(privateKeyString);
-    if (secretBytes.length === 64)
-        return base58Encode(secretBytes.subarray(32));
-    if (secretBytes.length === 32) {
-        // Derive pubkey from 32-byte seed
-        const keyObj = crypto.createPrivateKey({
-            key: Buffer.concat([
-                Buffer.from("302e020100300506032b657004220420", "hex"),
-                secretBytes,
-            ]),
-            format: "der",
-            type: "pkcs8",
-        });
-        const pubDer = crypto
-            .createPublicKey(keyObj)
-            .export({ type: "spki", format: "der" });
-        return base58Encode(pubDer.subarray(12, 44));
-    }
-    throw new Error(`Invalid Solana secret key length: ${secretBytes.length}`);
-}
-// ── Base58 (Bitcoin alphabet) ─────────────────────────────────────────
-const B58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-function base58Encode(data) {
-    let num = BigInt(`0x${Buffer.from(data).toString("hex")}`);
-    const chars = [];
-    while (num > 0n) {
-        chars.unshift(B58[Number(num % 58n)]);
-        num /= 58n;
-    }
-    for (const byte of data) {
-        if (byte === 0)
-            chars.unshift("1");
-        else
-            break;
-    }
-    return chars.join("") || "1";
-}
-function base58Decode(str) {
-    if (str.length === 0)
-        return Buffer.alloc(0);
-    let num = 0n;
-    for (const c of str) {
-        const i = B58.indexOf(c);
-        if (i === -1)
-            throw new Error(`Invalid base58: ${c}`);
-        num = num * 58n + BigInt(i);
-    }
-    const hex = num.toString(16).padStart(2, "0");
-    const bytes = Buffer.from(hex.length % 2 ? `0${hex}` : hex, "hex");
-    let zeros = 0;
-    for (const c of str) {
-        if (c === "1")
-            zeros++;
-        else
-            break;
-    }
-    return zeros > 0 ? Buffer.concat([Buffer.alloc(zeros), bytes]) : bytes;
-}
-/** Sentinel values that appear as env placeholders – skip without error. */
-const PLACEHOLDER_RE = /^\[?\s*(REDACTED|PLACEHOLDER|TODO|CHANGEME|EMPTY)\s*]?$/i;
-function decodeSolanaPrivateKey(key) {
-    if (PLACEHOLDER_RE.test(key)) {
-        throw new Error("placeholder value");
-    }
-    // Only attempt JSON array parse when the content looks like a numeric array
-    // e.g. [1,2,3,...] — not [REDACTED] or other bracket-wrapped strings
-    if (key.startsWith("[") && key.endsWith("]") && /^\[\s*\d/.test(key)) {
-        try {
-            const parsed = JSON.parse(key);
-            if (!Array.isArray(parsed) ||
-                !parsed.every((v) => typeof v === "number")) {
-                throw new Error("not a numeric array");
-            }
-            return Buffer.from(parsed);
-        }
-        catch {
-            throw new Error("Invalid JSON byte-array format");
-        }
-    }
-    return base58Decode(key);
-}
-// ── Key validation ────────────────────────────────────────────────────
-const HEX_RE = /^[0-9a-fA-F]+$/;
-export function validateEvmPrivateKey(key) {
-    const cleaned = key.startsWith("0x") ? key.slice(2) : key;
-    if (cleaned.length !== 64)
-        return {
-            valid: false,
-            chain: "evm",
-            address: null,
-            error: "Must be 64 hex characters",
-        };
-    if (!HEX_RE.test(cleaned))
-        return {
-            valid: false,
-            chain: "evm",
-            address: null,
-            error: "Invalid hex characters",
-        };
-    try {
-        return {
-            valid: true,
-            chain: "evm",
-            address: deriveEvmAddress(key),
-            error: null,
-        };
-    }
-    catch (err) {
-        return {
-            valid: false,
-            chain: "evm",
-            address: null,
-            error: `Derivation failed: ${err instanceof Error ? err.message : err}`,
-        };
-    }
-}
-export function validateSolanaPrivateKey(key) {
-    try {
-        const bytes = decodeSolanaPrivateKey(key);
-        if (bytes.length !== 64 && bytes.length !== 32) {
-            return {
-                valid: false,
-                chain: "solana",
-                address: null,
-                error: `Must be 32 or 64 bytes, got ${bytes.length}`,
-            };
-        }
-        return {
-            valid: true,
-            chain: "solana",
-            address: deriveSolanaAddress(key),
-            error: null,
-        };
-    }
-    catch (err) {
-        return {
-            valid: false,
-            chain: "solana",
-            address: null,
-            error: `Invalid key: ${err instanceof Error ? err.message : err}`,
-        };
-    }
-}
-/** Auto-detect chain from key format and validate. */
-export function validatePrivateKey(key) {
-    const trimmed = key.trim();
-    if (trimmed.startsWith("0x") ||
-        (trimmed.length === 64 && HEX_RE.test(trimmed)))
-        return validateEvmPrivateKey(trimmed);
-    return validateSolanaPrivateKey(trimmed);
-}
-/** Mask a secret string for safe display (e.g. logs, UI). */
-export function maskSecret(value) {
-    if (!value || value.length <= 8)
-        return "****";
-    return `${value.slice(0, 4)}...${value.slice(-4)}`;
-}
-// ── Key generation ────────────────────────────────────────────────────
-export function generateWalletKeys() {
-    const evmPrivateKey = generateEvmPrivateKey();
-    const solana = generateSolanaKeypair();
-    return {
-        evmPrivateKey,
-        evmAddress: deriveEvmAddress(evmPrivateKey),
-        solanaPrivateKey: solana.privateKey,
-        solanaAddress: solana.publicKey,
-    };
-}
-export function generateWalletForChain(chain) {
-    if (chain === "evm") {
-        const pk = generateEvmPrivateKey();
-        return { chain, address: deriveEvmAddress(pk), privateKey: pk };
-    }
-    const sol = generateSolanaKeypair();
-    return {
-        chain: "solana",
-        address: sol.publicKey,
-        privateKey: sol.privateKey,
-    };
-}
-/** Validate key, store in process.env. Caller persists to config if needed. */
-export function importWallet(chain, privateKey) {
-    const trimmed = privateKey.trim();
-    if (chain === "evm") {
-        const v = validateEvmPrivateKey(trimmed);
-        if (!v.valid)
-            return { success: false, chain, address: null, error: v.error };
-        process.env.EVM_PRIVATE_KEY = trimmed.startsWith("0x")
-            ? trimmed
-            : `0x${trimmed}`;
-        logger.info(`[wallet] Imported EVM wallet: ${v.address}`);
-        return { success: true, chain, address: v.address, error: null };
-    }
-    const v = validateSolanaPrivateKey(trimmed);
-    if (!v.valid)
-        return { success: false, chain, address: null, error: v.error };
-    process.env.SOLANA_PRIVATE_KEY = trimmed;
-    logger.info(`[wallet] Imported Solana wallet: ${v.address}`);
-    return { success: true, chain, address: v.address, error: null };
-}
-/** Derive addresses from env keys. Works without a running runtime. */
-export function getWalletAddresses() {
-    let evmAddress = null;
-    let solanaAddress = null;
-    const evmKey = process.env.EVM_PRIVATE_KEY;
-    if (evmKey && !PLACEHOLDER_RE.test(evmKey)) {
-        try {
-            evmAddress = deriveEvmAddress(evmKey);
-        }
-        catch (e) {
-            logger.warn(`Bad EVM key: ${e}`);
-        }
-    }
-    const solKey = process.env.SOLANA_PRIVATE_KEY;
-    if (solKey && !PLACEHOLDER_RE.test(solKey)) {
-        try {
-            solanaAddress = deriveSolanaAddress(solKey);
-        }
-        catch (e) {
-            logger.warn(`Bad SOL key: ${e}`);
-        }
-    }
-    if (!evmAddress) {
-        const managedEvmAddress = process.env[MANAGED_EVM_ADDRESS_ENV_KEY];
-        if (managedEvmAddress) {
-            const trimmed = managedEvmAddress.trim();
-            if (/^0x[0-9a-fA-F]{40}$/.test(trimmed)) {
-                evmAddress = trimmed;
-            }
-            else {
-                logger.warn("Bad managed EVM address in env");
-            }
-        }
-    }
-    if (!solanaAddress) {
-        const managedSolanaAddress = process.env[MANAGED_SOLANA_ADDRESS_ENV_KEY];
-        if (managedSolanaAddress) {
-            const trimmed = managedSolanaAddress.trim();
-            try {
-                const decoded = base58Decode(trimmed);
-                if (decoded.length === 32) {
-                    solanaAddress = trimmed;
-                }
-                else {
-                    logger.warn("Bad managed Solana address in env");
-                }
-            }
-            catch {
-                logger.warn("Bad managed Solana address in env");
-            }
-        }
-    }
-    return { evmAddress, solanaAddress };
-}
-function rpcJsonRequest(body) {
-    return {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
-        body,
-    };
-}
-function describeRpcEndpoint(url) {
-    try {
-        return new URL(url).host;
-    }
-    catch {
-        return "rpc";
-    }
-}
-/** Parse JSON from a fetch response. If the body isn't JSON, throw with the raw text. */
-async function jsonOrThrow(res) {
-    const text = await res.text();
-    if (!res.ok)
-        throw new Error(text.slice(0, 200) || `HTTP ${res.status}`);
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        throw new Error(text.slice(0, 200) || "Invalid JSON");
-    }
-}
-export async function fetchSolanaBalances(address, heliusKey) {
-    const url = `https://mainnet.helius-rpc.com/?api-key=${heliusKey}`;
-    const rpc = (body) => ({
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
-        body,
-    });
-    let solBalance = "0";
-    try {
-        const data = await jsonOrThrow(await fetch(url, rpc(JSON.stringify({
-            jsonrpc: "2.0",
-            id: 1,
-            method: "getBalance",
-            params: [address],
-        }))));
-        if (data.error?.message)
-            throw new Error(data.error.message);
-        solBalance = ((data.result?.value ?? 0) / 1e9).toFixed(9);
-    }
-    catch (err) {
-        logger.warn(`SOL balance fetch failed: ${err instanceof Error ? err.message : err}`);
-    }
-    const tokens = [];
-    try {
-        const data = await jsonOrThrow(await fetch(url, rpc(JSON.stringify({
-            jsonrpc: "2.0",
-            id: 2,
-            method: "getAssetsByOwner",
-            params: {
-                ownerAddress: address,
-                displayOptions: { showFungible: true, showNativeBalance: true },
-                page: 1,
-                limit: 100,
-            },
-        }))));
-        if (data.error?.message)
-            throw new Error(data.error.message);
-        for (const item of data.result?.items ?? []) {
-            if (item.interface !== "FungibleToken" &&
-                item.interface !== "FungibleAsset")
-                continue;
-            const dec = item.token_info?.decimals ?? 0;
-            const raw = item.token_info?.balance ?? 0;
-            tokens.push({
-                symbol: item.token_info?.symbol ?? item.content?.metadata?.symbol ?? "???",
-                name: item.content?.metadata?.name ?? "Unknown",
-                mint: item.id,
-                balance: dec > 0 ? (raw / 10 ** dec).toString() : raw.toString(),
-                decimals: dec,
-                valueUsd: item.token_info?.price_info?.total_price?.toFixed(2) ?? "0",
-                logoUrl: item.content?.links?.image ?? "",
-            });
-        }
-    }
-    catch (err) {
-        logger.warn(`Solana token fetch failed: ${err instanceof Error ? err.message : err}`);
-    }
-    return { solBalance, solValueUsd: "0", tokens };
-}
-export async function fetchSolanaNativeBalanceViaRpc(address, rpcUrls) {
-    const urls = [...new Set(rpcUrls)].filter((u) => Boolean(u?.trim()));
-    const errors = [];
-    for (const rpcUrl of urls) {
-        try {
-            const data = await jsonOrThrow(await fetch(rpcUrl, rpcJsonRequest(JSON.stringify({
-                jsonrpc: "2.0",
-                id: 1,
-                method: "getBalance",
-                params: [address],
-            }))));
-            if (data.error?.message)
-                throw new Error(data.error.message);
-            const solBalance = ((data.result?.value ?? 0) / 1e9).toFixed(9);
-            return { solBalance, solValueUsd: "0", tokens: [] };
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            errors.push(`${describeRpcEndpoint(rpcUrl)}: ${msg}`);
-        }
-    }
-    throw new Error(errors.join(" | ").slice(0, 400) || "Solana RPC unavailable");
-}

package/packages/agent/src/api/whatsapp-routes.d.ts

@@ -1,39 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-import type { WhatsAppPairingEvent } from "../services/whatsapp-pairing";
-export type WhatsAppPairingEventLike = WhatsAppPairingEvent;
-export interface WhatsAppPairingSessionLike {
-    start(): Promise<void>;
-    stop(): void;
-    getStatus(): string;
-}
-export interface WhatsAppRouteState {
-    whatsappPairingSessions: Map<string, WhatsAppPairingSessionLike>;
-    broadcastWs?: (data: Record<string, unknown>) => void;
-    config: {
-        connectors?: Record<string, unknown>;
-    };
-    runtime?: {
-        getService(type: string): unknown | null;
-    };
-    saveConfig: () => void;
-    workspaceDir: string;
-}
-export interface WhatsAppRouteDeps {
-    sanitizeAccountId: (accountId: string) => string;
-    whatsappAuthExists: (workspaceDir: string, accountId: string) => boolean;
-    whatsappLogout: (workspaceDir: string, accountId: string) => Promise<void>;
-    createWhatsAppPairingSession: (options: {
-        authDir: string;
-        accountId: string;
-        onEvent: (event: WhatsAppPairingEventLike) => void;
-    }) => WhatsAppPairingSessionLike;
-}
-export declare const MAX_PAIRING_SESSIONS = 10;
-export declare function handleWhatsAppRoute(req: IncomingMessage, res: ServerResponse, pathname: string, method: string, state: WhatsAppRouteState, deps: WhatsAppRouteDeps): Promise<boolean>;
-export declare function applyWhatsAppQrOverride(plugins: {
-    id: string;
-    validationErrors: unknown[];
-    configured: boolean;
-    qrConnected?: boolean;
-}[], workspaceDir: string): void;
-//# sourceMappingURL=whatsapp-routes.d.ts.map

package/packages/agent/src/api/whatsapp-routes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"whatsapp-routes.d.ts","sourceRoot":"","sources":["../../../../../src/api/whatsapp-routes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAEjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAGzE,MAAM,MAAM,wBAAwB,GAAG,oBAAoB,CAAC;AAE5D,MAAM,WAAW,0BAA0B;IACzC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,IAAI,IAAI,IAAI,CAAC;IACb,SAAS,IAAI,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,kBAAkB;IACjC,uBAAuB,EAAE,GAAG,CAAC,MAAM,EAAE,0BAA0B,CAAC,CAAC;IACjE,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IACtD,MAAM,EAAE;QACN,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KACtC,CAAC;IACF,OAAO,CAAC,EAAE;QACR,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;KAC1C,CAAC;IACF,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,iBAAiB;IAChC,iBAAiB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,CAAC;IACjD,kBAAkB,EAAE,CAAC,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC;IACzE,cAAc,EAAE,CAAC,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3E,4BAA4B,EAAE,CAAC,OAAO,EAAE;QACtC,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,CAAC,KAAK,EAAE,wBAAwB,KAAK,IAAI,CAAC;KACpD,KAAK,0BAA0B,CAAC;CAClC;AAGD,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAavC,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,cAAc,EACnB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,kBAAkB,EACzB,IAAI,EAAE,iBAAiB,GACtB,OAAO,CAAC,OAAO,CAAC,CA+LlB;AAED,wBAAgB,uBAAuB,CACrC,OAAO,EAAE;IACP,EAAE,EAAE,MAAM,CAAC;IACX,gBAAgB,EAAE,OAAO,EAAE,CAAC;IAC5B,UAAU,EAAE,OAAO,CAAC;IACpB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,EAAE,EACH,YAAY,EAAE,MAAM,GACnB,IAAI,CAmBN"}