@galaxy-kj/core-stellar-sdk 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Galaxy DevKit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,576 @@
+# @galaxy/core/stellar-sdk
+
+
+Enhanced Stellar SDK for Galaxy DevKit with comprehensive support for Stellar operations including claimable balances and liquidity pools.
+
+## Features
+
+- ✅ Wallet creation and management
+- ✅ Account operations (balance, info, history)
+- ✅ Payments and transactions
+- ✅ Trustline management
+- ✅ Claimable balances
+- ✅ Liquidity pool operations (AMM)
+- ✅ Network switching (testnet/mainnet)
+- ✅ React hooks support
+
+
+A comprehensive TypeScript SDK for Stellar blockchain operations, providing high-level abstractions over the Stellar SDK for common operations including account management, payments, assets, and sponsored reserves.
+
+
+## Installation
+
+```bash
+npm install @galaxy/core/stellar-sdk
+```
+
+## Features
+
+- **Account Management**: Create, fund, and manage Stellar accounts
+- **Payments**: Send XLM and custom assets with ease
+- **Asset Operations**: Create trustlines, issue assets, manage balances
+- **Transaction Building**: Simplified transaction construction and submission
+- **Sponsored Reserves**: Enable users to hold assets without XLM reserves
+- **Network Support**: Testnet and Mainnet configuration
+
+## Quick Start
+
+```typescript
+import { StellarService, NetworkConfig } from '@galaxy/core/stellar-sdk';
+
+// Configure for testnet
+const config: NetworkConfig = {
+  network: 'testnet',
+  horizonUrl: 'https://horizon-testnet.stellar.org',
+  passphrase: 'Test SDF Network ; September 2015',
+};
+
+// Initialize the service
+const stellar = new StellarService(config);
+
+// Create a new account
+const keypair = Keypair.random();
+await stellar.createAccount(keypair.publicKey(), '100');
+```
+
+## Sponsored Reserves
+
+The sponsored reserves module enables sponsor accounts to pay base reserves for another account's ledger entries. This is essential for user onboarding without requiring new users to hold XLM.
+
+### Key Concepts
+
+- **Sponsor**: Account that pays the reserve requirements
+- **Sponsored**: Account that benefits from the sponsorship
+- **Base Reserve**: Currently 0.5 XLM per ledger entry
+- **Supported Entries**: Accounts, trustlines, offers, data entries, claimable balances, signers
+
+### Basic Usage
+
+#### Create a Sponsored Account
+
+```typescript
+import {
+  SponsoredAccountBuilder,
+  calculateEntryReserve,
+} from '@galaxy/core/stellar-sdk';
+import { Keypair } from '@stellar/stellar-sdk';
+
+const networkConfig = {
+  network: 'testnet' as const,
+  horizonUrl: 'https://horizon-testnet.stellar.org',
+  passphrase: 'Test SDF Network ; September 2015',
+};
+
+const sponsorKeypair = Keypair.fromSecret('SPONSOR_SECRET');
+const newUserKeypair = Keypair.random();
+
+// Calculate cost
+const cost = calculateEntryReserve('account', 1);
+console.log('Sponsorship cost:', cost, 'XLM');
+
+// Create sponsored account
+const builder = new SponsoredAccountBuilder(networkConfig);
+const result = await builder.createSponsoredAccount(
+  sponsorKeypair.secret(),
+  newUserKeypair.secret(),
+  '0' // Starting balance can be 0 when sponsored
+);
+
+console.log('Account created:', result.hash);
+```
+
+#### Create Sponsored Trustlines
+
+```typescript
+import {
+  SponsoredTrustlineBuilder,
+  getDetailedBreakdown,
+} from '@galaxy/core/stellar-sdk';
+
+const assets = [
+  { assetCode: 'USDC', assetIssuer: 'GBBD47IF6LWK7P7MDEVSCWR7DPUWV3NY3DTQEVFL4NAT4AQH3ZLLFLA5' },
+  { assetCode: 'EURC', assetIssuer: 'GDHU6WRG4IEQXM5NZ4BMPKOXHW76MZM4Y2IEMFDVXBSDP6SJY4ITNPP2' },
+];
+
+// Calculate cost
+const breakdown = getDetailedBreakdown([{ type: 'trustline', count: assets.length }]);
+console.log('Total cost:', breakdown.totalCost, 'XLM');
+
+// Create sponsored trustlines
+const builder = new SponsoredTrustlineBuilder(networkConfig);
+const result = await builder.createMultipleSponsoredTrustlines(
+  sponsorKeypair.secret(),
+  userKeypair.secret(),
+  assets
+);
+
+console.log('Trustlines created:', result.sponsoredEntries.length);
+```
+
+#### User Onboarding Template
+
+For complete user onboarding (account + trustlines + data entries):
+
+```typescript
+import {
+  UserOnboardingTemplate,
+  calculateOnboardingCost,
+  SponsoredReservesManager,
+} from '@galaxy/core/stellar-sdk';
+
+const onboardingConfig = {
+  sponsorPublicKey: sponsorKeypair.publicKey(),
+  newUserPublicKey: newUserKeypair.publicKey(),
+  startingBalance: '0',
+  trustlines: [
+    { assetCode: 'USDC', assetIssuer: 'GBBD47IF...' },
+    { assetCode: 'PLATFORM', assetIssuer: 'GPLATFORM...' },
+  ],
+  dataEntries: [
+    { name: 'onboarded_at', value: new Date().toISOString() },
+    { name: 'platform', value: 'galaxy-devkit' },
+  ],
+  memo: 'Welcome to Galaxy!',
+};
+
+// Calculate cost
+const cost = calculateOnboardingCost(onboardingConfig);
+console.log('Total onboarding cost:', cost.totalCost, 'XLM');
+
+// Check sponsor eligibility
+const manager = new SponsoredReservesManager(networkConfig);
+const eligibility = await manager.checkSponsorshipEligibility(
+  sponsorKeypair.publicKey(),
+  cost
+);
+
+if (!eligibility.eligible) {
+  console.error('Sponsor needs more XLM:', eligibility.shortfall);
+  return;
+}
+
+// Execute onboarding
+const template = new UserOnboardingTemplate(networkConfig);
+const result = await template.onboardUser(
+  onboardingConfig,
+  sponsorKeypair.secret(),
+  newUserKeypair.secret()
+);
+
+console.log('User onboarded:', result.hash);
+```
+
+#### Claimable Balances for Airdrops
+
+Create sponsored claimable balances for token airdrops:
+
+```typescript
+import { ClaimableBalanceTemplate } from '@galaxy/core/stellar-sdk';
+
+const recipients = [
+  { destination: 'GUSER1...', amount: '100' },
+  { destination: 'GUSER2...', amount: '100' },
+  { destination: 'GUSER3...', amount: '100' },
+];
+
+const asset = { code: 'PLATFORM', issuer: 'GPLATFORM...' };
+const expirationTime = Math.floor(Date.now() / 1000) + 30 * 24 * 60 * 60; // 30 days
+
+const template = new ClaimableBalanceTemplate(networkConfig);
+const results = await template.createSponsoredAirdrop(
+  sponsorKeypair.secret(),
+  sourceKeypair.secret(),
+  asset,
+  recipients,
+  expirationTime
+);
+
+console.log('Airdrop created:', results.length, 'batches');
+```
+
+#### Vesting Schedules
+
+Create time-locked token vesting:
+
+```typescript
+import { ClaimableBalanceTemplate } from '@galaxy/core/stellar-sdk';
+
+// Create 4-tranche vesting over 1 year
+const vestingSchedule = ClaimableBalanceTemplate.createLinearVestingSchedule(
+  '10000', // Total tokens
+  4, // Number of tranches
+  Math.floor(Date.now() / 1000) + 90 * 24 * 60 * 60, // Start in 90 days
+  90 * 24 * 60 * 60 // 90 days between tranches
+);
+
+const template = new ClaimableBalanceTemplate(networkConfig);
+const result = await template.createSponsoredVesting(
+  sponsorKeypair.secret(),
+  sourceKeypair.secret(),
+  asset,
+  recipientPublicKey,
+  vestingSchedule
+);
+
+console.log('Vesting created:', result.sponsoredEntries.length, 'tranches');
+```
+
+### Query Sponsored Entries
+
+```typescript
+import { SponsoredReservesManager } from '@galaxy/core/stellar-sdk';
+
+const manager = new SponsoredReservesManager(networkConfig);
+
+// Get entries sponsored FOR an account
+const entriesFor = await manager.getSponsoredEntries(userPublicKey);
+
+// Get entries sponsored BY an account
+const entriesBy = await manager.getEntriesSponsoredBy(sponsorPublicKey);
+
+// Filter by type
+const trustlines = await manager.getSponsoredEntries(userPublicKey, {
+  entryType: 'trustline',
+});
+```
+
+### Revoking Sponsorship
+
+```typescript
+const manager = new SponsoredReservesManager(networkConfig);
+
+// Revoke account sponsorship
+await manager.revokeAccountSponsorship(
+  sponsorKeypair.secret(),
+  accountPublicKey
+);
+
+// Revoke trustline sponsorship
+await manager.revokeTrustlineSponsorship(
+  sponsorKeypair.secret(),
+  accountPublicKey,
+  { code: 'USDC', issuer: 'GBBD47IF...' }
+);
+```
+
+
+## Liquidity Pool Operations
+
+Liquidity pools enable automated market making (AMM) on Stellar using the constant product formula (x * y = k). Provide liquidity to pools and earn fees from trades.
+
+### Finding Pools
+
+```typescript
+import { Asset } from '@galaxy/core-stellar-sdk';
+
+// Find pools for asset pair
+const xlm = Asset.native();
+const usdc = new Asset('USDC', 'GBBD47IF6LWK7P7MDEVSCWR7DPUWV3NY3DTQEVFL4NAT4AQH3ZLLFLA5');
+
+const pools = await service.getPoolsForAssets(xlm, usdc, 5);
+console.log('Found', pools.length, 'pools');
+
+// Get specific pool details
+const pool = await service.getLiquidityPool(poolId);
+console.log('Reserve A:', pool.reserveA);
+console.log('Reserve B:', pool.reserveB);
+console.log('Total Shares:', pool.totalShares);
+```
+
+### Depositing Liquidity
+
+```typescript
+// Estimate deposit first
+const estimate = await service.estimatePoolDeposit(
+  poolId,
+  '100.0000000', // Amount of asset A
+  '500.0000000'  // Amount of asset B
+);
+
+console.log('Expected shares:', estimate.shares);
+console.log('Price impact:', estimate.priceImpact, '%');
+console.log('Pool share:', estimate.poolShare, '%');
+
+// Deposit with slippage protection
+const depositResult = await service.depositLiquidity(wallet, {
+  poolId: poolId,
+  maxAmountA: '100.0000000',
+  maxAmountB: '500.0000000',
+  slippageTolerance: '0.01', // 1% slippage tolerance
+  memo: 'LP deposit'
+}, password);
+
+console.log('Transaction Hash:', depositResult.hash);
+```
+
+### Withdrawing Liquidity
+
+```typescript
+// Get your shares
+const userShares = await service.getLiquidityPoolShares(wallet.publicKey, poolId);
+console.log('Your shares:', userShares);
+
+// Estimate withdrawal
+const withdrawEstimate = await service.estimatePoolWithdraw(
+  poolId,
+  '10.0000000' // Shares to withdraw
+);
+
+console.log('Expected Asset A:', withdrawEstimate.amountA);
+console.log('Expected Asset B:', withdrawEstimate.amountB);
+
+// Withdraw with slippage protection
+const withdrawResult = await service.withdrawLiquidity(wallet, {
+  poolId: poolId,
+  shares: '10.0000000',
+  slippageTolerance: '0.01',
+  memo: 'LP withdrawal'
+}, password);
+```
+
+### Pool Analytics
+
+```typescript
+import {
+  calculateShareValue,
+  calculateImpermanentLoss,
+  formatPoolAssets,
+  calculateSpotPrice
+} from '@galaxy/core-stellar-sdk';
+
+// Get pool analytics
+const analytics = await service.getPoolAnalytics(poolId);
+console.log('TVL:', analytics.tvl);
+console.log('Share Price:', analytics.sharePrice);
+
+// Calculate your position value
+const { valueA, valueB } = calculateShareValue(userShares, pool);
+console.log('Your position - Asset A:', valueA);
+console.log('Your position - Asset B:', valueB);
+
+// Calculate impermanent loss
+const initialPrice = '5.0000000'; // Price when you entered
+const currentPrice = calculateSpotPrice(pool.reserveA, pool.reserveB);
+const il = calculateImpermanentLoss(initialPrice, currentPrice);
+console.log('Impermanent Loss:', il, '%');
+
+// Format pool name
+const poolName = formatPoolAssets(pool);
+console.log('Pool:', poolName); // e.g., "XLM/USDC"
+```
+
+### Slippage Protection
+
+```typescript
+import { calculateMinimumAmounts, calculatePriceBounds } from '@galaxy/core-stellar-sdk';
+
+// Calculate minimum amounts with slippage tolerance
+const { minAmountA, minAmountB } = calculateMinimumAmounts(
+  '100.0000000',
+  '500.0000000',
+  '0.01' // 1% slippage
+);
+
+// Calculate price bounds
+const currentPrice = calculateSpotPrice(pool.reserveA, pool.reserveB);
+const { minPrice, maxPrice } = calculatePriceBounds(currentPrice, '0.02'); // 2% tolerance
+
+// Deposit with price bounds
+await service.depositLiquidity(wallet, {
+  poolId: poolId,
+  maxAmountA: '100.0000000',
+  maxAmountB: '500.0000000',
+  minPrice: minPrice,
+  maxPrice: maxPrice,
+  memo: 'Price protected deposit'
+}, password);
+```
+
+### Price Calculation Examples
+
+```typescript
+// Constant product formula: x * y = k
+const k = new BigNumber(pool.reserveA).multipliedBy(pool.reserveB);
+
+// Spot price: P = reserveB / reserveA
+const spotPrice = new BigNumber(pool.reserveB).dividedBy(pool.reserveA);
+
+// First deposit shares: sqrt(amountA * amountB)
+const shares = Math.sqrt(amountA * amountB);
+
+// Subsequent deposit shares: min(amountA/reserveA, amountB/reserveB) * totalShares
+const ratioA = amountA / pool.reserveA;
+const ratioB = amountB / pool.reserveB;
+const ratio = Math.min(ratioA, ratioB);
+const depositShares = ratio * pool.totalShares;
+
+// Withdrawal amounts: (shares / totalShares) * reserves
+const withdrawAmountA = (shares / pool.totalShares) * pool.reserveA;
+const withdrawAmountB = (shares / pool.totalShares) * pool.reserveB;
+```
+
+### Important Notes
+
+- **Pool IDs**: 64-character hex strings generated by Stellar network
+- **Precision**: All amounts use 7 decimal places
+- **Slippage**: Default 1%, warn if price impact > 5%
+- **Estimation**: Always estimate before executing operations
+- **First Deposit**: Uses geometric mean (sqrt) for share calculation
+- **Subsequent**: Uses proportional ratio to maintain pool balance
+
+## React Hook Usage
+
+### Cost Calculation
+
+
+```typescript
+import {
+  calculateEntryReserve,
+  getDetailedBreakdown,
+  calculateTotalCost,
+} from '@galaxy/core/stellar-sdk';
+
+// Single entry cost
+const accountCost = calculateEntryReserve('account', 1); // 1 XLM (2 base reserves)
+const trustlineCost = calculateEntryReserve('trustline', 1); // 0.5 XLM
+
+// Detailed breakdown
+const breakdown = getDetailedBreakdown([
+  { type: 'account', count: 1 },
+  { type: 'trustline', count: 3 },
+  { type: 'data', count: 2 },
+]);
+
+console.log('Breakdown:');
+for (const item of breakdown.entries) {
+  console.log(`  ${item.description}: ${item.cost} XLM`);
+}
+console.log('Total:', breakdown.totalCost, 'XLM');
+console.log('Transaction fee:', breakdown.transactionFee, 'XLM');
+```
+
+### Multi-Signature Support
+
+For scenarios where keys are held by different parties:
+
+```typescript
+import { SponsoredAccountBuilder } from '@galaxy/core/stellar-sdk';
+
+const builder = new SponsoredAccountBuilder(networkConfig);
+
+// Build unsigned transaction
+const { xdr, requiredSigners } = await builder.buildUnsignedTransaction(
+  sponsorPublicKey,
+  newUserPublicKey,
+  '0'
+);
+
+console.log('Transaction XDR:', xdr);
+console.log('Required signers:', requiredSigners);
+
+// Each party signs the XDR separately
+// Then submit using signAndSubmitSponsorshipTransaction
+```
+
+## API Reference
+
+### Classes
+
+| Class | Description |
+|-------|-------------|
+| `StellarService` | Core service for Stellar operations |
+| `SponsoredReservesManager` | Main manager for sponsored reserves operations |
+| `SponsoredAccountBuilder` | Builder for sponsored account creation |
+| `SponsoredTrustlineBuilder` | Builder for sponsored trustlines |
+| `SponsoredClaimableBalanceBuilder` | Builder for sponsored claimable balances |
+| `SponsoredSignerBuilder` | Builder for sponsored signers |
+| `SponsoredDataEntryBuilder` | Builder for sponsored data entries |
+| `UserOnboardingTemplate` | Template for complete user onboarding |
+| `ClaimableBalanceTemplate` | Template for airdrops and vesting |
+| `MultiOperationTemplate` | Template for batch operations |
+
+### Utility Functions
+
+| Function | Description |
+|----------|-------------|
+| `calculateEntryReserve(type, count)` | Calculate reserve for entry type |
+| `getDetailedBreakdown(entries)` | Get detailed cost breakdown |
+| `calculateTotalCost(config)` | Calculate total sponsorship cost |
+| `calculateOnboardingCost(config)` | Calculate user onboarding cost |
+| `validatePublicKey(key)` | Validate Stellar public key |
+| `validateSecretKey(key)` | Validate Stellar secret key |
+| `validateSponsorBalance(sponsor, required)` | Check sponsor has sufficient balance |
+
+### Types
+
+```typescript
+interface NetworkConfig {
+  network: 'testnet' | 'mainnet';
+  horizonUrl: string;
+  passphrase: string;
+}
+
+type SponsoredEntryType =
+  | 'account'
+  | 'trustline'
+  | 'offer'
+  | 'data'
+  | 'claimableBalance'
+  | 'signer';
+
+interface SponsorshipResult {
+  hash: string;
+  ledger: number;
+  status: 'success' | 'failed';
+  feePaid: string;
+  sponsoredEntries: SponsoredEntry[];
+}
+
+interface UserOnboardingConfig {
+  sponsorPublicKey: string;
+  newUserPublicKey: string;
+  startingBalance: string;
+  trustlines?: Array<{ assetCode: string; assetIssuer: string }>;
+  dataEntries?: Array<{ name: string; value: string }>;
+  memo?: string;
+}
+```
+
+## Examples
+
+See the [examples directory](../../docs/examples/stellar-sdk/) for complete working examples:
+
+- `15-sponsor-account.ts` - Create sponsored accounts
+- `16-sponsor-trustline.ts` - Create sponsored trustlines
+- `17-onboarding-flow.ts` - Complete user onboarding flow
+
+## Testing
+
+```bash
+cd packages/core/stellar-sdk
+npm test
+```
+
+## License
+
+MIT License - see the [LICENSE](../../../LICENSE) file for details.

package/dist/claimable-balances/claimable-balance-manager.d.ts

@@ -0,0 +1,99 @@
+/**
+ * @fileoverview Claimable Balance Manager
+ * @description Manages creation, claiming, and querying of claimable balances
+ * @author Galaxy DevKit Team
+ * @version 1.0.0
+ * @since 2024-12-01
+ */
+import { Asset, Horizon } from '@stellar/stellar-sdk';
+import { ClaimableBalance, CreateClaimableBalanceParams, ClaimBalanceParams, QueryClaimableBalancesParams, ClaimableBalanceResult } from './types';
+import { Wallet } from '../types/stellar-types';
+/**
+ * Claimable Balance Manager class
+ * @class ClaimableBalanceManager
+ * @description Handles all claimable balance operations
+ */
+export declare class ClaimableBalanceManager {
+    private server;
+    private networkPassphrase;
+    private networkUtils;
+    constructor(server: Horizon.Server, networkPassphrase: string);
+    /**
+     * Creates a claimable balance
+     * @param wallet - Source wallet
+     * @param params - Create claimable balance parameters
+     * @param password - Wallet password
+     * @returns Promise<ClaimableBalanceResult>
+     */
+    createClaimableBalance(wallet: Wallet, params: CreateClaimableBalanceParams, password: string): Promise<ClaimableBalanceResult>;
+    /**
+     * Claims a claimable balance
+     * @param wallet - Claimant wallet
+     * @param params - Claim parameters
+     * @param password - Wallet password
+     * @returns Promise<ClaimableBalanceResult>
+     */
+    claimBalance(wallet: Wallet, params: ClaimBalanceParams, password: string): Promise<ClaimableBalanceResult>;
+    /**
+     * Gets claimable balance details by ID
+     * @param balanceId - Balance ID
+     * @returns Promise<ClaimableBalance>
+     */
+    getBalanceDetails(balanceId: string): Promise<ClaimableBalance>;
+    /**
+     * Queries claimable balances
+     * @param params - Query parameters
+     * @returns Promise<ClaimableBalance[]>
+     */
+    getClaimableBalances(params?: QueryClaimableBalancesParams): Promise<ClaimableBalance[]>;
+    /**
+     * Gets claimable balances for a specific account (as claimant)
+     * @param publicKey - Account public key
+     * @param limit - Number of results to return
+     * @returns Promise<ClaimableBalance[]>
+     */
+    getClaimableBalancesForAccount(publicKey: string, limit?: number): Promise<ClaimableBalance[]>;
+    /**
+     * Gets claimable balances by asset
+     * @param asset - Asset to filter by
+     * @param limit - Number of results to return
+     * @returns Promise<ClaimableBalance[]>
+     */
+    getClaimableBalancesByAsset(asset: Asset, limit?: number): Promise<ClaimableBalance[]>;
+    /**
+     * Validates create claimable balance parameters
+     * @param params - Parameters to validate
+     * @throws Error if invalid
+     */
+    private validateCreateParams;
+    /**
+     * Validates balance ID format
+     * @param balanceId - Balance ID to validate
+     * @returns boolean
+     */
+    private isValidBalanceId;
+    /**
+     * Extracts balance ID from transaction result
+     * @param result - Transaction result
+     * @returns Promise<Balance ID>
+     */
+    private extractBalanceId;
+    /**
+     * Maps Horizon API balance to our ClaimableBalance type
+     * @param horizonBalance - Horizon API balance
+     * @returns ClaimableBalance
+     */
+    private mapHorizonBalanceToClaimableBalance;
+    /**
+     * Maps Horizon predicate to our ClaimPredicate type
+     * @param horizonPredicate - Horizon predicate
+     * @returns ClaimPredicate
+     */
+    private mapHorizonPredicateToPredicate;
+    /**
+     * Estimates transaction fee
+     * @returns Promise<string>
+     */
+    private estimateFee;
+}
+//# sourceMappingURL=claimable-balance-manager.d.ts.map

package/dist/claimable-balances/claimable-balance-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claimable-balance-manager.d.ts","sourceRoot":"","sources":["../../src/claimable-balances/claimable-balance-manager.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAEL,KAAK,EAGL,OAAO,EAGR,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,gBAAgB,EAEhB,4BAA4B,EAC5B,kBAAkB,EAClB,4BAA4B,EAC5B,sBAAsB,EACvB,MAAM,SAAS,CAAC;AAKjB,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAIhD;;;;GAIG;AACH,qBAAa,uBAAuB;IAClC,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,iBAAiB,CAAS;IAClC,OAAO,CAAC,YAAY,CAAe;gBAEvB,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,iBAAiB,EAAE,MAAM;IAM7D;;;;;;OAMG;IACG,sBAAsB,CAC1B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,4BAA4B,EACpC,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,sBAAsB,CAAC;IAkElC;;;;;;OAMG;IACG,YAAY,CAChB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,kBAAkB,EAC1B,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,sBAAsB,CAAC;IAwDlC;;;;OAIG;IACG,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAsBrE;;;;OAIG;IACG,oBAAoB,CACxB,MAAM,GAAE,4BAAiC,GACxC,OAAO,CAAC,gBAAgB,EAAE,CAAC;IA+C9B;;;;;OAKG;IACG,8BAA8B,CAClC,SAAS,EAAE,MAAM,EACjB,KAAK,GAAE,MAAW,GACjB,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAW9B;;;;;OAKG;IACG,2BAA2B,CAC/B,KAAK,EAAE,KAAK,EACZ,KAAK,GAAE,MAAW,GACjB,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAO9B;;;;OAIG;IACH,OAAO,CAAC,oBAAoB;IA6B5B;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IAKxB;;;;OAIG;YACW,gBAAgB;IAgC9B;;;;OAIG;IACH,OAAO,CAAC,mCAAmC;IA2B3C;;;;OAIG;IACH,OAAO,CAAC,8BAA8B;IAyCtC;;;OAGG;YACW,WAAW;CAQ1B"}