@kadi.build/deploy-ability 0.0.1

package/dist/targets/akash/wallet-manager.d.ts

@@ -0,0 +1,526 @@
+/**
+ * Akash Network Wallet Connection Module
+ *
+ * Provides a clean, step-by-step API for connecting to Keplr wallet via WalletConnect.
+ * This is a LIBRARY - no QR code display, no prompts, just pure wallet operations.
+ *
+ * Key Improvements from kadi-deploy:
+ * - ✅ ZERO CLI dependencies (no QRCode, chalk, enquirer)
+ * - ✅ ZERO `any` types (was 5 any types)
+ * - ✅ Split into 4 clear steps for composability
+ * - ✅ Result types for all operations
+ * - ✅ Natural, intuitive API design
+ *
+ * Architecture:
+ * ```
+ * Step 1: initWalletConnect()     → Create SignClient
+ *    ↓
+ * Step 2: generateConnectionUri() → Get URI for QR code
+ *    ↓
+ * Step 3: waitForApproval()       → Poll for user approval
+ *    ↓
+ * Step 4: createWalletContext()   → Get ready-to-use wallet
+ * ```
+ *
+ * Design Philosophy:
+ * Each step is independent and composable. Callers can:
+ * - Display QR codes however they want (terminal, web, mobile)
+ * - Add their own timeout logic
+ * - Implement custom retry mechanisms
+ * - Show progress however they prefer
+ *
+ * @module targets/akash/wallet
+ */
+import { SignClient } from '@walletconnect/sign-client';
+import type { SessionTypes } from '@walletconnect/types';
+import type { Result } from '../../types/index.js';
+import type { WalletContext } from './types.js';
+import { WalletError } from '../../errors/index.js';
+import { type AkashNetwork } from './environment.js';
+/**
+ * WalletConnect client wrapper
+ *
+ * Contains the SignClient and metadata for managing connections.
+ */
+export interface WalletConnectClient {
+    /** SignClient instance for WalletConnect operations */
+    readonly client: InstanceType<typeof SignClient>;
+    /** Project metadata for display in wallets */
+    readonly metadata: {
+        readonly name: string;
+        readonly description: string;
+        readonly url: string;
+        readonly icons: readonly string[];
+    };
+}
+/**
+ * Connection URI result
+ *
+ * Contains the URI to display as QR code and approval promise.
+ */
+export interface ConnectionUriResult {
+    /** URI to display as QR code or clickable link */
+    readonly uri: string;
+    /** Approval promise that resolves when user approves */
+    readonly approval: () => Promise<SessionTypes.Struct>;
+}
+/**
+ * Connection approval result
+ *
+ * Contains the approved session and account information.
+ */
+export interface ApprovalResult {
+    /** Approved WalletConnect session */
+    readonly session: SessionTypes.Struct;
+    /** Connected wallet address */
+    readonly address: string;
+    /** Chain ID that was connected */
+    readonly chainId: string;
+}
+/**
+ * Step 1: Initialize WalletConnect client
+ *
+ * Creates a WalletConnect SignClient with proper configuration.
+ * This is a one-time setup that can be reused for multiple connections.
+ *
+ * @param projectId - WalletConnect Cloud project ID
+ * @param metadata - Optional app metadata (defaults to KADI Deploy)
+ * @returns Result with WalletConnect client or error
+ *
+ * @example
+ * ```typescript
+ * // Initialize with your project ID
+ * const clientResult = await initWalletConnect('your-project-id-here');
+ *
+ * if (!clientResult.success) {
+ *   console.error('Failed to initialize:', clientResult.error);
+ *   return;
+ * }
+ *
+ * const wcClient = clientResult.data;
+ * console.log('WalletConnect ready!');
+ * ```
+ */
+export declare function initWalletConnect(projectId: string, metadata?: {
+    name: string;
+    description: string;
+    url: string;
+    icons: string[];
+}): Promise<Result<WalletConnectClient, WalletError>>;
+/**
+ * Step 2: Generate connection URI for QR code display
+ *
+ * Creates a new pairing and generates the WalletConnect URI.
+ * The caller is responsible for displaying this URI as a QR code.
+ *
+ * @param wcClient - Initialized WalletConnect client from step 1
+ * @param network - Akash network to connect to
+ * @returns Result with URI and pairing info or error
+ *
+ * @example
+ * ```typescript
+ * // Generate URI for QR code
+ * const uriResult = await generateConnectionUri(wcClient, 'mainnet');
+ *
+ * if (!uriResult.success) {
+ *   console.error('Failed to generate URI:', uriResult.error);
+ *   return;
+ * }
+ *
+ * const { uri, pairingTopic, approval } = uriResult.data;
+ *
+ * // Caller displays QR code however they want:
+ * // - Terminal: QRCode.generate(uri)
+ * // - Web: <QRCode value={uri} />
+ * // - Or just show as text: console.log(uri)
+ * console.log('Scan this QR code:', uri);
+ * ```
+ */
+export declare function generateConnectionUri(wcClient: WalletConnectClient, network: AkashNetwork): Promise<Result<ConnectionUriResult, WalletError>>;
+/**
+ * Step 3: Wait for user to approve connection
+ *
+ * Polls for wallet approval with configurable timeout.
+ * Returns immediately when user approves or rejects.
+ *
+ * @param approval - Approval promise from step 2
+ * @param timeoutMs - Maximum wait time in milliseconds (default: 5 minutes)
+ * @returns Result with approved session or error
+ *
+ * @example
+ * ```typescript
+ * // Wait for user to scan QR and approve
+ * console.log('Waiting for approval...');
+ *
+ * const approvalResult = await waitForApproval(
+ *   approval,
+ *   60000 // 60 second timeout
+ * );
+ *
+ * if (!approvalResult.success) {
+ *   if (approvalResult.error.code === 'APPROVAL_TIMEOUT') {
+ *     console.log('User did not approve in time');
+ *   } else if (approvalResult.error.code === 'APPROVAL_REJECTED') {
+ *     console.log('User rejected connection');
+ *   }
+ *   return;
+ * }
+ *
+ * const { session, address } = approvalResult.data;
+ * console.log(`Connected to ${address}!`);
+ * ```
+ */
+export declare function waitForApproval(approval: () => Promise<SessionTypes.Struct>, timeoutMs?: number): Promise<Result<ApprovalResult, WalletError>>;
+/**
+ * Step 4: Create complete wallet context for Akash operations
+ *
+ * Finalizes the connection by creating signers and querying account data.
+ * Returns a ready-to-use WalletContext for all Akash operations.
+ *
+ * @param wcClient - WalletConnect client from step 1
+ * @param approvalResult - Approval result from step 3
+ * @param network - Akash network being used
+ * @returns Result with complete wallet context or error
+ *
+ * @example
+ * ```typescript
+ * // Create final wallet context
+ * const walletResult = await createWalletContext(
+ *   wcClient,
+ *   approvalResult.data,
+ *   'mainnet'
+ * );
+ *
+ * if (!walletResult.success) {
+ *   console.error('Failed to create wallet:', walletResult.error);
+ *   return;
+ * }
+ *
+ * const wallet = walletResult.data;
+ * console.log('Wallet ready!');
+ * console.log('Address:', wallet.address);
+ * console.log('Chain:', wallet.chainId);
+ *
+ * // Now ready for Akash operations
+ * const deployment = await deployToAkash({ wallet, ... });
+ * ```
+ */
+export declare function createWalletContext(wcClient: WalletConnectClient, approvalResult: ApprovalResult, network: AkashNetwork): Promise<Result<WalletContext, WalletError>>;
+/**
+ * Create wallet context from any offline signer
+ *
+ * Use this for **automated deployments** where you have direct access to a signer
+ * (e.g., agent wallet, CI/CD, hardware wallet, KMS) instead of interactive wallet
+ * connection via browser or WalletConnect.
+ *
+ * **Security Model:**
+ * This function accepts a **signer interface**, NOT a private key or mnemonic!
+ * The signer can sign transactions without exposing the underlying key.
+ *
+ * **Common Use Cases:**
+ * - Self-deploying agents (signer from encrypted storage)
+ * - CI/CD pipelines (signer from secrets manager)
+ * - Hardware wallets (Ledger - key never leaves device)
+ * - Cloud KMS (AWS/GCP - key stays in cloud)
+ * - Multi-signature wallets (threshold signing)
+ *
+ * @param signer - Any offline signer (must implement OfflineAminoSigner & OfflineDirectSigner)
+ * @param network - Akash network to connect to
+ * @returns Result with wallet context ready for deployments
+ *
+ * @example Agent with encrypted wallet
+ * ```typescript
+ * import { DirectSecp256k1Wallet } from '@cosmjs/proto-signing';
+ * import { createWalletContextFromSigner } from 'deploy-ability/akash';
+ *
+ * // Agent loads signer from secure storage (mnemonic never exposed to caller)
+ * const agentSigner = await myAgent.wallet.getSigner();
+ *
+ * // Create wallet context
+ * const walletCtx = await createWalletContextFromSigner(agentSigner, 'mainnet');
+ *
+ * if (walletCtx.success) {
+ *   // Ready to deploy - signer will handle signing internally
+ *   await deployToAkash({
+ *     wallet: walletCtx.data,
+ *     certificate: cert,
+ *     projectRoot: './',
+ *     profile: 'prod'
+ *   });
+ * }
+ * ```
+ *
+ * @example CI/CD with secrets manager
+ * ```typescript
+ * // Load signer from AWS Secrets Manager / GitHub Secrets
+ * const mnemonic = await loadFromSecretsManager('deploy-wallet-key');
+ * const signer = await DirectSecp256k1Wallet.fromMnemonic(mnemonic, {
+ *   prefix: 'akash'
+ * });
+ *
+ * const walletCtx = await createWalletContextFromSigner(signer, 'testnet');
+ * // Now deploy without any user interaction
+ * ```
+ *
+ * @example Hardware wallet (Ledger)
+ * ```typescript
+ * import Ledger from '@cosmjs/ledger-amino';
+ *
+ * // Connect to Ledger - key never leaves device
+ * const transport = await TransportWebUSB.create();
+ * const ledgerSigner = new Ledger(transport, {
+ *   hdPaths: [makeCosmoshubPath(0)],
+ *   prefix: 'akash'
+ * });
+ *
+ * const walletCtx = await createWalletContextFromSigner(ledgerSigner, 'mainnet');
+ * // Ledger will prompt for approval when signing
+ * ```
+ *
+ * @example Cloud KMS
+ * ```typescript
+ * // Custom signer using AWS KMS / GCP KMS
+ * class KmsSigner implements OfflineSigner {
+ *   constructor(private keyId: string) {}
+ *
+ *   async signDirect(address: string, signDoc: SignDoc) {
+ *     // Sign using KMS - key never leaves cloud
+ *     return await kms.sign(this.keyId, signDoc);
+ *   }
+ * }
+ *
+ * const kmsSigner = new KmsSigner('arn:aws:kms:...');
+ * const walletCtx = await createWalletContextFromSigner(kmsSigner, 'mainnet');
+ * ```
+ */
+export declare function createWalletContextFromSigner(signer: WalletContext['signer'], network: AkashNetwork): Promise<Result<WalletContext, WalletError>>;
+/**
+ * Disconnect an active WalletConnect session
+ *
+ * Cleanly disconnects from the wallet, clearing the session and cleaning up
+ * all internal resources (relay transport, heartbeat, event listeners).
+ *
+ * This ensures the Node.js event loop can exit by releasing all timers and
+ * connections. Without this cleanup, the WalletConnect client keeps the
+ * process alive indefinitely.
+ *
+ * Always call this when done with wallet operations to prevent hanging.
+ *
+ * Note: This only applies to WalletConnect sessions. Wallets created
+ * with `createWalletContextFromSigner()` don't need disconnection.
+ *
+ * @param wallet - Wallet context to disconnect
+ * @returns Result indicating success or error
+ *
+ * @example
+ * ```typescript
+ * // Disconnect when done
+ * const result = await disconnectWallet(wallet);
+ *
+ * if (result.success) {
+ *   console.log('Wallet disconnected');
+ * } else {
+ *   console.warn('Disconnect failed:', result.error);
+ * }
+ * ```
+ */
+export declare function disconnectWallet(wallet: WalletContext): Promise<Result<void, WalletError>>;
+/**
+ * Complete wallet connection flow (convenience function)
+ *
+ * Combines all 4 steps into a single function for simple use cases.
+ * For more control, use the individual step functions.
+ *
+ * @param projectId - WalletConnect project ID
+ * @param network - Akash network to connect to
+ * @param options - Optional configuration
+ * @returns Result with wallet context or error
+ *
+ * @example
+ * ```typescript
+ * // Simple one-call connection
+ * const walletResult = await connectWallet(
+ *   'your-project-id',
+ *   'mainnet',
+ *   {
+ *     onUriGenerated: (uri) => {
+ *       // Display QR code
+ *       QRCode.generate(uri);
+ *       console.log('Scan QR code with Keplr');
+ *     },
+ *     timeoutMs: 60000
+ *   }
+ * );
+ *
+ * if (!walletResult.success) {
+ *   console.error('Connection failed:', walletResult.error);
+ *   return;
+ * }
+ *
+ * const wallet = walletResult.data;
+ * console.log('Connected to:', wallet.address);
+ * ```
+ */
+export declare function connectWallet(projectId: string, network: AkashNetwork, options?: {
+    /** Callback when URI is generated (for QR display) */
+    onUriGenerated?: (uri: string) => void;
+    /** Connection timeout in milliseconds */
+    timeoutMs?: number;
+    /** App metadata */
+    metadata?: {
+        name: string;
+        description: string;
+        url: string;
+        icons: string[];
+    };
+}): Promise<Result<WalletContext, WalletError>>;
+/**
+ * Create wallet context from mnemonic (for agent-controlled wallets)
+ *
+ * ⚠️ **CRITICAL SECURITY WARNING** ⚠️
+ *
+ * This function is ONLY for scenarios where YOU control the mnemonic:
+ * - ✅ Your own automation (CI/CD, personal scripts)
+ * - ✅ Your own agent (running on infrastructure you control)
+ * - ✅ Custodial services YOU operate (creating wallets for your users)
+ *
+ * **NEVER use this if:**
+ * - ❌ Someone else's agent asks for your mnemonic
+ * - ❌ Third-party service requests your mnemonic
+ * - ❌ You don't fully control where the mnemonic is stored/used
+ *
+ * **For third-party agents/services:**
+ * Use `connectWallet()` with WalletConnect instead! This lets you approve
+ * transactions on YOUR device without exposing your mnemonic.
+ *
+ * **Security Model:**
+ * ```
+ * ┌─────────────────────────────────────────────────────────────┐
+ * │ WHO CONTROLS THE AGENT?                                      │
+ * ├─────────────────────────────────────────────────────────────┤
+ * │                                                              │
+ * │  YOU control it:                                            │
+ * │  ✅ createWalletFromMnemonic() - You trust your own code    │
+ * │                                                              │
+ * │  SOMEONE ELSE controls it:                                  │
+ * │  ✅ connectWallet() - WalletConnect for approval           │
+ * │  ❌ createWalletFromMnemonic() - NEVER share mnemonic!      │
+ * │                                                              │
+ * └─────────────────────────────────────────────────────────────┘
+ * ```
+ *
+ * **Common Use Cases:**
+ *
+ * @example 1. Your own CI/CD pipeline
+ * ```typescript
+ * // Mnemonic stored in GitHub Secrets / GitLab CI Variables
+ * const mnemonic = process.env.DEPLOYMENT_WALLET_MNEMONIC!;
+ * const wallet = await createWalletFromMnemonic(mnemonic, 'mainnet');
+ *
+ * if (wallet.success) {
+ *   // Automated deployment from CI/CD
+ *   await deployToAkash({
+ *     wallet: wallet.data,
+ *     projectRoot: './',
+ *     profile: 'production'
+ *   });
+ * }
+ * ```
+ *
+ * @example 2. Your own agent with encrypted storage
+ * ```typescript
+ * // Agent loads its OWN mnemonic (not user's!)
+ * class DeploymentAgent {
+ *   async deploy(projectConfig: Config) {
+ *     // Agent uses its own wallet to pay for deployments
+ *     const mnemonic = await this.secrets.getEncryptedMnemonic();
+ *     const wallet = await createWalletFromMnemonic(mnemonic, 'mainnet');
+ *
+ *     if (wallet.success) {
+ *       // Agent deploys using its own funds
+ *       return deployToAkash({
+ *         wallet: wallet.data,
+ *         ...projectConfig
+ *       });
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @example 3. Custodial wallet service (you operate the service)
+ * ```typescript
+ * // Service creates and manages wallets FOR users
+ * class CustodialWalletService {
+ *   async createUserWallet(userId: string) {
+ *     // Generate new wallet for user
+ *     const { DirectSecp256k1HdWallet } = await import('@cosmjs/proto-signing');
+ *     const newWallet = await DirectSecp256k1HdWallet.generate(24);
+ *     const mnemonic = newWallet.mnemonic;
+ *
+ *     // Store encrypted mnemonic in your secure database
+ *     await this.db.storeEncryptedMnemonic(userId, mnemonic);
+ *
+ *     return { userId, address: (await newWallet.getAccounts())[0].address };
+ *   }
+ *
+ *   async deployForUser(userId: string, projectConfig: Config) {
+ *     // Load user's mnemonic from secure storage
+ *     const mnemonic = await this.db.getDecryptedMnemonic(userId);
+ *     const wallet = await createWalletFromMnemonic(mnemonic, 'mainnet');
+ *
+ *     if (wallet.success) {
+ *       // Deploy on user's behalf
+ *       return deployToAkash({
+ *         wallet: wallet.data,
+ *         ...projectConfig
+ *       });
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @example 4. WRONG - Never do this!
+ * ```typescript
+ * // ❌ DANGEROUS - Third-party agent asking for your mnemonic!
+ * const thirdPartyAgent = new SomeoneElsesAgent();
+ *
+ * // ❌ DO NOT DO THIS!
+ * await thirdPartyAgent.deploy({
+ *   mnemonic: myMnemonic,  // ❌ Now they can steal all your funds!
+ *   project: './my-app'
+ * });
+ *
+ * // ✅ DO THIS INSTEAD - Use WalletConnect!
+ * const wallet = await connectWallet(projectId, 'mainnet', {
+ *   onUriGenerated: (uri) => {
+ *     console.log('Scan QR code to approve');
+ *     // You approve on YOUR device, agent never gets mnemonic
+ *   }
+ * });
+ * await thirdPartyAgent.deploy({ wallet: wallet.data, ... });
+ * ```
+ *
+ * **Implementation Notes for Future:**
+ *
+ * This function should:
+ * 1. Import DirectSecp256k1HdWallet from @cosmjs/proto-signing
+ * 2. Create signer with proper network prefix:
+ *    - mainnet/testnet → 'akash'
+ *    - sandbox → 'akash'
+ * 3. Call createWalletContextFromSigner() with the signer
+ * 4. Return Result<WalletContext, WalletError>
+ *
+ * Dependencies needed:
+ * - @cosmjs/proto-signing (DirectSecp256k1HdWallet)
+ *
+ * Error handling:
+ * - Invalid mnemonic format
+ * - Network configuration issues
+ * - Account fetch failures
+ *
+ * @param mnemonic - BIP39 mnemonic phrase (12 or 24 words)
+ * @param network - Akash network to connect to
+ * @returns Result with wallet context or error
+ */
+export declare function createWalletFromMnemonic(_mnemonic: string, network: AkashNetwork): Promise<Result<WalletContext, WalletError>>;
+//# sourceMappingURL=wallet-manager.d.ts.map

package/dist/targets/akash/wallet-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet-manager.d.ts","sourceRoot":"","sources":["../../../src/targets/akash/wallet-manager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAIxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,aAAa,EAAe,MAAM,YAAY,CAAC;AAC7D,OAAO,EAAE,WAAW,EAAoB,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAoB,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAEvE;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,uDAAuD;IACvD,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC,OAAO,UAAU,CAAC,CAAC;IAEjD,8CAA8C;IAC9C,QAAQ,CAAC,QAAQ,EAAE;QACjB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;QAC7B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QACrB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;KACnC,CAAC;CACH;AAED;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,kDAAkD;IAClD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAErB,wDAAwD;IACxD,QAAQ,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;CACvD;AAED;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,qCAAqC;IACrC,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC,MAAM,CAAC;IAEtC,+BAA+B;IAC/B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEzB,kCAAkC;IAClC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,MAAM,EACjB,QAAQ,CAAC,EAAE;IACT,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB,GACA,OAAO,CAAC,MAAM,CAAC,mBAAmB,EAAE,WAAW,CAAC,CAAC,CAgDnD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,mBAAmB,EAC7B,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,MAAM,CAAC,mBAAmB,EAAE,WAAW,CAAC,CAAC,CA2DnD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAsB,eAAe,CACnC,QAAQ,EAAE,MAAM,OAAO,CAAC,YAAY,CAAC,MAAM,CAAC,EAC5C,SAAS,GAAE,MAAe,GACzB,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC,CA6F9C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,mBAAmB,EAC7B,cAAc,EAAE,cAAc,EAC9B,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC,CAuF7C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsFG;AACH,wBAAsB,6BAA6B,CACjD,MAAM,EAAE,aAAa,CAAC,QAAQ,CAAC,EAC/B,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC,CAoE7C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC,CA8HpC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAsB,aAAa,CACjC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,YAAY,EACrB,OAAO,CAAC,EAAE;IACR,sDAAsD;IACtD,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,yCAAyC;IACzC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,mBAAmB;IACnB,QAAQ,CAAC,EAAE;QACT,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,EAAE,MAAM,CAAC;QACpB,GAAG,EAAE,MAAM,CAAC;QACZ,KAAK,EAAE,MAAM,EAAE,CAAC;KACjB,CAAC;CACH,GACA,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC,CA6B7C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmJG;AACH,wBAAsB,wBAAwB,CAC5C,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC,CAwE7C"}