@elizaos/agent 0.25.8 → 2.0.0-alpha.83

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

@@ -0,0 +1,513 @@
+/**
+ * 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

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1 @@
+{"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"}